@kodelyth/line 2026.5.39 → 2026.5.42

package/src/card-command.ts

@@ -0,0 +1,347 @@
+import type { KlawPluginApi } from "klaw/plugin-sdk/core";
+import type { ReplyPayload } from "klaw/plugin-sdk/reply-runtime";
+import { normalizeLowercaseStringOrEmpty } from "klaw/plugin-sdk/string-coerce-runtime";
+import {
+  createActionCard,
+  createImageCard,
+  createInfoCard,
+  createListCard,
+  createReceiptCard,
+  type CardAction,
+  type ListItem,
+} from "./flex-templates.js";
+import type { LineChannelData } from "./types.js";
+
+const CARD_USAGE = `Usage: /card <type> "title" "body" [options]
+
+Types:
+  info "Title" "Body" ["Footer"]
+  image "Title" "Caption" --url <image-url>
+  action "Title" "Body" --actions "Btn1|url1,Btn2|text2"
+  list "Title" "Item1|Desc1,Item2|Desc2"
+  receipt "Title" "Item1:$10,Item2:$20" --total "$30"
+  confirm "Question?" --yes "Yes|data" --no "No|data"
+  buttons "Title" "Text" --actions "Btn1|url1,Btn2|data2"
+
+Examples:
+  /card info "Welcome" "Thanks for joining!"
+  /card image "Product" "Check it out" --url https://example.com/img.jpg
+  /card action "Menu" "Choose an option" --actions "Order|/order,Help|/help"`;
+
+function buildLineReply(lineData: LineChannelData): ReplyPayload {
+  return {
+    channelData: {
+      line: lineData,
+    },
+  };
+}
+
+/**
+ * Parse action string format: "Label|data,Label2|data2"
+ * Data can be a URL (uri action) or plain text (message action) or key=value (postback)
+ */
+function parseActions(actionsStr: string | undefined): CardAction[] {
+  if (!actionsStr) {
+    return [];
+  }
+
+  const results: CardAction[] = [];
+
+  for (const part of actionsStr.split(",")) {
+    const [label, data] = part
+      .trim()
+      .split("|")
+      .map((s) => s.trim());
+    if (!label) {
+      continue;
+    }
+
+    const actionData = data || label;
+
+    if (actionData.startsWith("http://") || actionData.startsWith("https://")) {
+      results.push({
+        label,
+        action: { type: "uri", label: label.slice(0, 20), uri: actionData },
+      });
+    } else if (actionData.includes("=")) {
+      results.push({
+        label,
+        action: {
+          type: "postback",
+          label: label.slice(0, 20),
+          data: actionData.slice(0, 300),
+          displayText: label,
+        },
+      });
+    } else {
+      results.push({
+        label,
+        action: { type: "message", label: label.slice(0, 20), text: actionData },
+      });
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Parse list items format: "Item1|Subtitle1,Item2|Subtitle2"
+ */
+function parseListItems(itemsStr: string): ListItem[] {
+  return itemsStr
+    .split(",")
+    .map((part) => {
+      const [title, subtitle] = part
+        .trim()
+        .split("|")
+        .map((s) => s.trim());
+      return { title: title || "", subtitle };
+    })
+    .filter((item) => item.title);
+}
+
+/**
+ * Parse receipt items format: "Item1:$10,Item2:$20"
+ */
+function parseReceiptItems(itemsStr: string): Array<{ name: string; value: string }> {
+  return itemsStr
+    .split(",")
+    .map((part) => {
+      const colonIndex = part.lastIndexOf(":");
+      if (colonIndex === -1) {
+        return { name: part.trim(), value: "" };
+      }
+      return {
+        name: part.slice(0, colonIndex).trim(),
+        value: part.slice(colonIndex + 1).trim(),
+      };
+    })
+    .filter((item) => item.name);
+}
+
+/**
+ * Parse quoted arguments from command string
+ * Supports: /card type "arg1" "arg2" "arg3" --flag value
+ */
+function parseCardArgs(argsStr: string): {
+  type: string;
+  args: string[];
+  flags: Record<string, string>;
+} {
+  const result: { type: string; args: string[]; flags: Record<string, string> } = {
+    type: "",
+    args: [],
+    flags: {},
+  };
+
+  // Extract type (first word)
+  const typeMatch = argsStr.match(/^(\w+)/);
+  if (typeMatch) {
+    result.type = normalizeLowercaseStringOrEmpty(typeMatch[1]);
+    argsStr = argsStr.slice(typeMatch[0].length).trim();
+  }
+
+  // Extract quoted arguments
+  const quotedRegex = /"([^"]*?)"/g;
+  let match;
+  while ((match = quotedRegex.exec(argsStr)) !== null) {
+    result.args.push(match[1]);
+  }
+
+  // Extract flags (--key value or --key "value")
+  const flagRegex = /--(\w+)\s+(?:"([^"]*?)"|(\S+))/g;
+  while ((match = flagRegex.exec(argsStr)) !== null) {
+    result.flags[match[1]] = match[2] ?? match[3];
+  }
+
+  return result;
+}
+
+export function registerLineCardCommand(api: KlawPluginApi): void {
+  api.registerCommand({
+    name: "card",
+    description: "Send a rich card message (LINE).",
+    acceptsArgs: true,
+    requireAuth: false,
+    handler: async (ctx) => {
+      const argsStr = ctx.args?.trim() ?? "";
+      if (!argsStr) {
+        return { text: CARD_USAGE };
+      }
+
+      const parsed = parseCardArgs(argsStr);
+      const { type, args, flags } = parsed;
+
+      if (!type) {
+        return { text: CARD_USAGE };
+      }
+
+      // Only LINE supports rich cards; fallback to text elsewhere.
+      if (ctx.channel !== "line") {
+        const fallbackText = args.join(" - ");
+        return { text: `[${type} card] ${fallbackText}`.trim() };
+      }
+
+      try {
+        switch (type) {
+          case "info": {
+            const [title = "Info", body = "", footer] = args;
+            const bubble = createInfoCard(title, body, footer);
+            return buildLineReply({
+              flexMessage: {
+                altText: `${title}: ${body}`.slice(0, 400),
+                contents: bubble,
+              },
+            });
+          }
+
+          case "image": {
+            const [title = "Image", caption = ""] = args;
+            const imageUrl = flags.url || flags.image;
+            if (!imageUrl) {
+              return { text: "Error: Image card requires --url <image-url>" };
+            }
+            const bubble = createImageCard(imageUrl, title, caption);
+            return buildLineReply({
+              flexMessage: {
+                altText: `${title}: ${caption}`.slice(0, 400),
+                contents: bubble,
+              },
+            });
+          }
+
+          case "action": {
+            const [title = "Actions", body = ""] = args;
+            const actions = parseActions(flags.actions);
+            if (actions.length === 0) {
+              return { text: 'Error: Action card requires --actions "Label1|data1,Label2|data2"' };
+            }
+            const bubble = createActionCard(title, body, actions, {
+              imageUrl: flags.url || flags.image,
+            });
+            return buildLineReply({
+              flexMessage: {
+                altText: `${title}: ${body}`.slice(0, 400),
+                contents: bubble,
+              },
+            });
+          }
+
+          case "list": {
+            const [title = "List", itemsStr = ""] = args;
+            const items = parseListItems(itemsStr || flags.items || "");
+            if (items.length === 0) {
+              return {
+                text: 'Error: List card requires items. Usage: /card list "Title" "Item1|Desc1,Item2|Desc2"',
+              };
+            }
+            const bubble = createListCard(title, items);
+            return buildLineReply({
+              flexMessage: {
+                altText: `${title}: ${items.map((i) => i.title).join(", ")}`.slice(0, 400),
+                contents: bubble,
+              },
+            });
+          }
+
+          case "receipt": {
+            const [title = "Receipt", itemsStr = ""] = args;
+            const items = parseReceiptItems(itemsStr || flags.items || "");
+            const total = flags.total ? { label: "Total", value: flags.total } : undefined;
+            const footer = flags.footer;
+
+            if (items.length === 0) {
+              return {
+                text: 'Error: Receipt card requires items. Usage: /card receipt "Title" "Item1:$10,Item2:$20" --total "$30"',
+              };
+            }
+
+            const bubble = createReceiptCard({ title, items, total, footer });
+            return buildLineReply({
+              flexMessage: {
+                altText: `${title}: ${items.map((i) => `${i.name} ${i.value}`).join(", ")}`.slice(
+                  0,
+                  400,
+                ),
+                contents: bubble,
+              },
+            });
+          }
+
+          case "confirm": {
+            const [question = "Confirm?"] = args;
+            const yesStr = flags.yes || "Yes|yes";
+            const noStr = flags.no || "No|no";
+
+            const [yesLabel, yesData] = yesStr.split("|").map((s) => s.trim());
+            const [noLabel, noData] = noStr.split("|").map((s) => s.trim());
+
+            return buildLineReply({
+              templateMessage: {
+                type: "confirm",
+                text: question,
+                confirmLabel: yesLabel || "Yes",
+                confirmData: yesData || "yes",
+                cancelLabel: noLabel || "No",
+                cancelData: noData || "no",
+                altText: question,
+              },
+            });
+          }
+
+          case "buttons": {
+            const [title = "Menu", text = "Choose an option"] = args;
+            const actionsStr = flags.actions || "";
+            const actionParts = parseActions(actionsStr);
+
+            if (actionParts.length === 0) {
+              return { text: 'Error: Buttons card requires --actions "Label1|data1,Label2|data2"' };
+            }
+
+            const templateActions: Array<{
+              type: "message" | "uri" | "postback";
+              label: string;
+              data?: string;
+              uri?: string;
+            }> = actionParts.map((a) => {
+              const action = a.action;
+              const label = action.label ?? a.label;
+              if (action.type === "uri") {
+                return { type: "uri" as const, label, uri: (action as { uri: string }).uri };
+              }
+              if (action.type === "postback") {
+                return {
+                  type: "postback" as const,
+                  label,
+                  data: (action as { data: string }).data,
+                };
+              }
+              return {
+                type: "message" as const,
+                label,
+                data: (action as { text: string }).text,
+              };
+            });
+
+            return buildLineReply({
+              templateMessage: {
+                type: "buttons",
+                title,
+                text,
+                thumbnailImageUrl: flags.url || flags.image,
+                actions: templateActions,
+              },
+            });
+          }
+
+          default:
+            return {
+              text: `Unknown card type: "${type}". Available types: info, image, action, list, receipt, confirm, buttons`,
+            };
+        }
+      } catch (err) {
+        return { text: `Error creating card: ${String(err)}` };
+      }
+    },
+  });
+}

package/src/channel-access-token.ts

@@ -0,0 +1,14 @@
+export function resolveLineChannelAccessToken(
+  explicit: string | undefined,
+  params: { accountId: string; channelAccessToken: string },
+): string {
+  if (explicit?.trim()) {
+    return explicit.trim();
+  }
+  if (!params.channelAccessToken) {
+    throw new Error(
+      `LINE channel access token missing for account "${params.accountId}" (set channels.line.channelAccessToken or LINE_CHANNEL_ACCESS_TOKEN).`,
+    );
+  }
+  return params.channelAccessToken.trim();
+}

package/src/channel-api.ts

@@ -0,0 +1,17 @@
+export { clearAccountEntryFields } from "klaw/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/account-id";
+import type { KlawConfig } from "klaw/plugin-sdk/account-resolution";
+import type { ChannelPlugin } from "klaw/plugin-sdk/core";
+import { listLineAccountIds, resolveDefaultLineAccountId, resolveLineAccount } from "./accounts.js";
+import { resolveExactLineGroupConfigKey } from "./group-keys.js";
+import type { LineConfig, ResolvedLineAccount } from "./types.js";
+
+export {
+  DEFAULT_ACCOUNT_ID,
+  listLineAccountIds,
+  resolveDefaultLineAccountId,
+  resolveExactLineGroupConfigKey,
+  resolveLineAccount,
+};
+
+export type { ChannelPlugin, LineConfig, KlawConfig, ResolvedLineAccount };

package/src/channel-setup-status.contract.test.ts

@@ -0,0 +1,70 @@
+import {
+  installChannelSetupContractSuite,
+  installChannelStatusContractSuite,
+} from "klaw/plugin-sdk/channel-test-helpers";
+import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
+import { describe, expect } from "vitest";
+import { linePlugin, lineSetupPlugin } from "../api.js";
+
+describe("line setup contract", () => {
+  installChannelSetupContractSuite({
+    plugin: lineSetupPlugin,
+    cases: [
+      {
+        name: "default account stores token and secret",
+        cfg: {} as KlawConfig,
+        input: {
+          channelAccessToken: "line-token",
+          channelSecret: "line-secret",
+        } as never,
+        expectedAccountId: "default",
+        assertPatchedConfig: (cfg) => {
+          expect(cfg.channels?.line?.enabled).toBe(true);
+          expect(cfg.channels?.line?.channelAccessToken).toBe("line-token");
+          expect(cfg.channels?.line?.channelSecret).toBe("line-secret");
+        },
+      },
+      {
+        name: "non-default env setup is rejected",
+        cfg: {} as KlawConfig,
+        accountId: "ops",
+        input: {
+          useEnv: true,
+        },
+        expectedAccountId: "ops",
+        expectedValidation: "LINE_CHANNEL_ACCESS_TOKEN can only be used for the default account.",
+      },
+    ],
+  });
+});
+
+describe("line status contract", () => {
+  installChannelStatusContractSuite({
+    plugin: linePlugin,
+    cases: [
+      {
+        name: "configured account produces a webhook status snapshot",
+        cfg: {
+          channels: {
+            line: {
+              enabled: true,
+              channelAccessToken: "line-token",
+              channelSecret: "line-secret",
+            },
+          },
+        } as KlawConfig,
+        runtime: {
+          accountId: "default",
+          running: true,
+        },
+        probe: { ok: true },
+        assertSnapshot: (snapshot) => {
+          expect(snapshot.accountId).toBe("default");
+          expect(snapshot.enabled).toBe(true);
+          expect(snapshot.configured).toBe(true);
+          expect(snapshot.mode).toBe("webhook");
+        },
+      },
+    ],
+  });
+});

package/src/channel-shared.ts

@@ -0,0 +1,48 @@
+import { describeWebhookAccountSnapshot } from "klaw/plugin-sdk/account-helpers";
+import { hasLineCredentials } from "./account-helpers.js";
+import { type ChannelPlugin, type ResolvedLineAccount } from "./channel-api.js";
+import { lineConfigAdapter } from "./config-adapter.js";
+import { LineChannelConfigSchema } from "./config-schema.js";
+
+const lineChannelMeta = {
+  id: "line",
+  label: "LINE",
+  selectionLabel: "LINE (Messaging API)",
+  detailLabel: "LINE Bot",
+  docsPath: "/channels/line",
+  docsLabel: "line",
+  blurb: "LINE Messaging API bot for Japan/Taiwan/Thailand markets.",
+  systemImage: "message.fill",
+} as const;
+
+export const lineChannelPluginCommon = {
+  meta: {
+    ...lineChannelMeta,
+    quickstartAllowFrom: true,
+  },
+  capabilities: {
+    chatTypes: ["direct", "group"],
+    reactions: false,
+    threads: false,
+    media: true,
+    nativeCommands: false,
+    blockStreaming: true,
+  },
+  reload: { configPrefixes: ["channels.line"] },
+  configSchema: LineChannelConfigSchema,
+  config: {
+    ...lineConfigAdapter,
+    isConfigured: (account: ResolvedLineAccount) => hasLineCredentials(account),
+    describeAccount: (account: ResolvedLineAccount) =>
+      describeWebhookAccountSnapshot({
+        account,
+        configured: hasLineCredentials(account),
+        extra: {
+          tokenSource: account.tokenSource ?? undefined,
+        },
+      }),
+  },
+} satisfies Pick<
+  ChannelPlugin<ResolvedLineAccount>,
+  "meta" | "capabilities" | "reload" | "configSchema" | "config"
+>;

package/src/channel.logout.test.ts

@@ -0,0 +1,145 @@
+import { createRuntimeEnv } from "klaw/plugin-sdk/plugin-test-runtime";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import type { KlawConfig, PluginRuntime, ResolvedLineAccount } from "../api.js";
+import { lineGatewayAdapter } from "./gateway.js";
+import { setLineRuntime } from "./runtime.js";
+
+const DEFAULT_ACCOUNT_ID = "default";
+
+type LineRuntimeMocks = {
+  replaceConfigFile: ReturnType<typeof vi.fn>;
+  resolveLineAccount: ReturnType<typeof vi.fn>;
+};
+
+function createRuntime(): { runtime: PluginRuntime; mocks: LineRuntimeMocks } {
+  const replaceConfigFile = vi.fn(async () => {});
+  const resolveLineAccount = vi.fn(
+    ({ cfg, accountId }: { cfg: KlawConfig; accountId?: string }) => {
+      const lineConfig = (cfg.channels?.line ?? {}) as {
+        tokenFile?: string;
+        secretFile?: string;
+        channelAccessToken?: string;
+        channelSecret?: string;
+        accounts?: Record<string, Record<string, unknown>>;
+      };
+      const entry =
+        accountId && accountId !== DEFAULT_ACCOUNT_ID
+          ? (lineConfig.accounts?.[accountId] ?? {})
+          : lineConfig;
+      const hasToken =
+        Boolean((entry as any).channelAccessToken) || Boolean((entry as any).tokenFile);
+      const hasSecret = Boolean((entry as any).channelSecret) || Boolean((entry as any).secretFile);
+      return { tokenSource: hasToken && hasSecret ? "config" : "none" };
+    },
+  );
+
+  const runtime = {
+    config: { replaceConfigFile },
+  } as unknown as PluginRuntime;
+
+  return { runtime, mocks: { replaceConfigFile, resolveLineAccount } };
+}
+
+function resolveAccount(
+  resolveLineAccount: LineRuntimeMocks["resolveLineAccount"],
+  cfg: KlawConfig,
+  accountId: string,
+): ResolvedLineAccount {
+  const resolver = resolveLineAccount as unknown as (params: {
+    cfg: KlawConfig;
+    accountId?: string;
+  }) => ResolvedLineAccount;
+  return resolver({ cfg, accountId });
+}
+
+async function runLogoutScenario(params: { cfg: KlawConfig; accountId: string }): Promise<{
+  result: Awaited<ReturnType<NonNullable<typeof lineGatewayAdapter.logoutAccount>>>;
+  mocks: LineRuntimeMocks;
+}> {
+  const { runtime, mocks } = createRuntime();
+  setLineRuntime(runtime);
+  const account = resolveAccount(mocks.resolveLineAccount, params.cfg, params.accountId);
+  const result = await lineGatewayAdapter.logoutAccount!({
+    accountId: params.accountId,
+    cfg: params.cfg,
+    account,
+    runtime: createRuntimeEnv(),
+  });
+  return { result, mocks };
+}
+
+describe("linePlugin gateway.logoutAccount", () => {
+  beforeEach(() => {
+    setLineRuntime(createRuntime().runtime);
+  });
+
+  it("clears tokenFile/secretFile on default account logout", async () => {
+    const cfg: KlawConfig = {
+      channels: {
+        line: {
+          tokenFile: "/tmp/token",
+          secretFile: "/tmp/secret",
+        },
+      },
+    };
+    const { result, mocks } = await runLogoutScenario({
+      cfg,
+      accountId: DEFAULT_ACCOUNT_ID,
+    });
+
+    expect(result.cleared).toBe(true);
+    expect(result.loggedOut).toBe(true);
+    expect(mocks.replaceConfigFile).toHaveBeenCalledWith({
+      nextConfig: {},
+      afterWrite: { mode: "auto" },
+    });
+  });
+
+  it("clears tokenFile/secretFile on account logout", async () => {
+    const cfg: KlawConfig = {
+      channels: {
+        line: {
+          accounts: {
+            primary: {
+              tokenFile: "/tmp/token",
+              secretFile: "/tmp/secret",
+            },
+          },
+        },
+      },
+    };
+    const { result, mocks } = await runLogoutScenario({
+      cfg,
+      accountId: "primary",
+    });
+
+    expect(result.cleared).toBe(true);
+    expect(result.loggedOut).toBe(true);
+    expect(mocks.replaceConfigFile).toHaveBeenCalledWith({
+      nextConfig: {},
+      afterWrite: { mode: "auto" },
+    });
+  });
+
+  it("does not write config when account has no token/secret fields", async () => {
+    const cfg: KlawConfig = {
+      channels: {
+        line: {
+          accounts: {
+            primary: {
+              name: "Primary",
+            },
+          },
+        },
+      },
+    };
+    const { result, mocks } = await runLogoutScenario({
+      cfg,
+      accountId: "primary",
+    });
+
+    expect(result.cleared).toBe(false);
+    expect(result.loggedOut).toBe(true);
+    expect(mocks.replaceConfigFile).not.toHaveBeenCalled();
+  });
+});

package/src/channel.runtime.ts

@@ -0,0 +1,3 @@
+export { monitorLineProvider } from "./monitor.js";
+export { probeLineBot } from "./probe.js";
+export { pushMessageLine } from "./send.js";