@kodelyth/line 2026.5.42 → 2026.6.2

package/src/card-command.ts

@@ -1,347 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,70 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,145 +0,0 @@
-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

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