@gakr-gakr/line 0.1.0

package/src/card-command.ts

@@ -0,0 +1,347 @@
+import type { AutoBotPluginApi } from "autobot/plugin-sdk/core";
+import type { ReplyPayload } from "autobot/plugin-sdk/reply-runtime";
+import { normalizeLowercaseStringOrEmpty } from "autobot/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: AutoBotPluginApi): 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 "autobot/plugin-sdk/core";
+import { DEFAULT_ACCOUNT_ID } from "autobot/plugin-sdk/account-id";
+import type { AutoBotConfig } from "autobot/plugin-sdk/account-resolution";
+import type { ChannelPlugin } from "autobot/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, AutoBotConfig, ResolvedLineAccount };

package/src/channel-shared.ts

@@ -0,0 +1,48 @@
+import { describeWebhookAccountSnapshot } from "autobot/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.runtime.ts

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

package/src/channel.setup.ts

@@ -0,0 +1,11 @@
+import { type ChannelPlugin, type ResolvedLineAccount } from "./channel-api.js";
+import { lineChannelPluginCommon } from "./channel-shared.js";
+import { lineSetupAdapter } from "./setup-core.js";
+import { lineSetupWizard } from "./setup-surface.js";
+
+export const lineSetupPlugin: ChannelPlugin<ResolvedLineAccount> = {
+  id: "line",
+  ...lineChannelPluginCommon,
+  setupWizard: lineSetupWizard,
+  setup: lineSetupAdapter,
+};

package/src/channel.ts

@@ -0,0 +1,155 @@
+import { createChatChannelPlugin } from "autobot/plugin-sdk/channel-core";
+import { createPairingPrefixStripper } from "autobot/plugin-sdk/channel-pairing";
+import { createRestrictSendersChannelSecurity } from "autobot/plugin-sdk/channel-policy";
+import { createEmptyChannelDirectoryAdapter } from "autobot/plugin-sdk/directory-runtime";
+import { createLazyRuntimeModule } from "autobot/plugin-sdk/lazy-runtime";
+import { resolveLineAccount } from "./accounts.js";
+import { lineBindingsAdapter } from "./bindings.js";
+import { type ChannelPlugin, type ResolvedLineAccount } from "./channel-api.js";
+import { lineChannelPluginCommon } from "./channel-shared.js";
+import { lineGatewayAdapter } from "./gateway.js";
+import { resolveLineGroupRequireMention } from "./group-policy.js";
+import { lineMessageAdapter, lineOutboundAdapter } from "./outbound.js";
+import { hasLineDirectives, parseLineDirectives } from "./reply-payload-transform.js";
+import { getLineRuntime } from "./runtime.js";
+import { lineSetupAdapter } from "./setup-core.js";
+import { lineSetupWizard } from "./setup-surface.js";
+import { lineStatusAdapter } from "./status.js";
+
+const loadLineChannelRuntime = createLazyRuntimeModule(() => import("./channel.runtime.js"));
+
+const lineSecurityAdapter = createRestrictSendersChannelSecurity<ResolvedLineAccount>({
+  channelKey: "line",
+  resolveDmPolicy: (account) => account.config.dmPolicy,
+  resolveDmAllowFrom: (account) => account.config.allowFrom,
+  resolveGroupPolicy: (account) => account.config.groupPolicy,
+  surface: "LINE groups",
+  openScope: "any member in groups",
+  groupPolicyPath: "channels.line.groupPolicy",
+  groupAllowFromPath: "channels.line.groupAllowFrom",
+  mentionGated: false,
+  policyPathSuffix: "dmPolicy",
+  approveHint: "autobot pairing approve line <code>",
+  normalizeDmEntry: (raw) => raw.replace(/^line:(?:user:)?/i, ""),
+});
+
+export const linePlugin: ChannelPlugin<ResolvedLineAccount> = createChatChannelPlugin({
+  base: {
+    id: "line",
+    ...lineChannelPluginCommon,
+    setupWizard: lineSetupWizard,
+    groups: {
+      resolveRequireMention: resolveLineGroupRequireMention,
+    },
+    messaging: {
+      targetPrefixes: ["line"],
+      normalizeTarget: (target) => {
+        const trimmed = target.trim();
+        if (!trimmed) {
+          return undefined;
+        }
+        return trimmed.replace(/^line:(group|room|user):/i, "").replace(/^line:/i, "");
+      },
+      resolveInboundConversation: lineBindingsAdapter.resolveInboundConversation,
+      transformReplyPayload: ({ payload }) => {
+        if (!payload.text || !hasLineDirectives(payload.text)) {
+          return payload;
+        }
+        return parseLineDirectives(payload);
+      },
+      targetResolver: {
+        looksLikeId: (id) => {
+          const trimmed = id?.trim();
+          if (!trimmed) {
+            return false;
+          }
+          return /^[UCR][a-f0-9]{32}$/i.test(trimmed) || /^line:/i.test(trimmed);
+        },
+        hint: "<userId|groupId|roomId>",
+      },
+    },
+    directory: createEmptyChannelDirectoryAdapter(),
+    setup: lineSetupAdapter,
+    status: lineStatusAdapter,
+    gateway: lineGatewayAdapter,
+    message: lineMessageAdapter,
+    bindings: lineBindingsAdapter,
+    conversationBindings: {
+      defaultTopLevelPlacement: "current",
+    },
+    agentPrompt: {
+      messageToolHints: () => [
+        "",
+        "### LINE Rich Messages",
+        "LINE supports rich visual messages. Use these directives in your reply when appropriate:",
+        "",
+        "**Quick Replies** (bottom button suggestions):",
+        "  [[quick_replies: Option 1, Option 2, Option 3]]",
+        "",
+        "**Location** (map pin):",
+        "  [[location: Place Name | Address | latitude | longitude]]",
+        "",
+        "**Confirm Dialog** (yes/no prompt):",
+        "  [[confirm: Question text? | Yes Label | No Label]]",
+        "",
+        "**Button Menu** (title + text + buttons):",
+        "  [[buttons: Title | Description | Btn1:action1, Btn2:https://url.com]]",
+        "",
+        "**Media Player Card** (music status):",
+        "  [[media_player: Song Title | Artist Name | Source | https://albumart.url | playing]]",
+        "  - Status: 'playing' or 'paused' (optional)",
+        "",
+        "**Event Card** (calendar events, meetings):",
+        "  [[event: Event Title | Date | Time | Location | Description]]",
+        "  - Time, Location, Description are optional",
+        "",
+        "**Agenda Card** (multiple events/schedule):",
+        "  [[agenda: Schedule Title | Event1:9:00 AM, Event2:12:00 PM, Event3:3:00 PM]]",
+        "",
+        "**Device Control Card** (smart devices, TVs, etc.):",
+        "  [[device: Device Name | Device Type | Status | Control1:data1, Control2:data2]]",
+        "",
+        "**Apple TV Remote** (full D-pad + transport):",
+        "  [[appletv_remote: Apple TV | Playing]]",
+        "",
+        "**Auto-converted**: Markdown tables become Flex cards, code blocks become styled cards.",
+        "",
+        "When to use rich messages:",
+        "- Use [[quick_replies:...]] when offering 2-4 clear options",
+        "- Use [[confirm:...]] for yes/no decisions",
+        "- Use [[buttons:...]] for menus with actions/links",
+        "- Use [[location:...]] when sharing a place",
+        "- Use [[media_player:...]] when showing what's playing",
+        "- Use [[event:...]] for calendar event details",
+        "- Use [[agenda:...]] for a day's schedule or event list",
+        "- Use [[device:...]] for smart device status/controls",
+        "- Tables/code in your response auto-convert to visual cards",
+      ],
+    },
+  },
+  pairing: {
+    text: {
+      idLabel: "lineUserId",
+      message: "AutoBot: your access has been approved.",
+      normalizeAllowEntry: createPairingPrefixStripper(/^line:(?:user:)?/i),
+      notify: async ({ cfg, id, message }) => {
+        const account = (getLineRuntime().channel.line?.resolveLineAccount ?? resolveLineAccount)({
+          cfg,
+        });
+        if (!account.channelAccessToken) {
+          throw new Error("LINE channel access token not configured");
+        }
+        const pushMessageLine =
+          getLineRuntime().channel.line?.pushMessageLine ??
+          (await loadLineChannelRuntime()).pushMessageLine;
+        await pushMessageLine(id, message, {
+          cfg,
+          accountId: account.accountId,
+          channelAccessToken: account.channelAccessToken,
+        });
+      },
+    },
+  },
+  security: lineSecurityAdapter,
+  outbound: lineOutboundAdapter,
+});

package/src/config-adapter.ts

@@ -0,0 +1,29 @@
+import { createScopedChannelConfigAdapter } from "autobot/plugin-sdk/channel-config-helpers";
+import {
+  listLineAccountIds,
+  resolveDefaultLineAccountId,
+  resolveLineAccount,
+  type ResolvedLineAccount,
+} from "./channel-api.js";
+
+function normalizeLineAllowFrom(entry: string): string {
+  return entry.replace(/^line:(?:user:)?/i, "");
+}
+
+export const lineConfigAdapter = createScopedChannelConfigAdapter<
+  ResolvedLineAccount,
+  ResolvedLineAccount
+>({
+  sectionKey: "line",
+  listAccountIds: listLineAccountIds,
+  resolveAccount: (cfg, accountId) =>
+    resolveLineAccount({ cfg, accountId: accountId ?? undefined }),
+  defaultAccountId: resolveDefaultLineAccountId,
+  clearBaseFields: ["channelSecret", "tokenFile", "secretFile"],
+  resolveAllowFrom: (account) => account.config.allowFrom,
+  formatAllowFrom: (allowFrom) =>
+    allowFrom
+      .map((entry) => String(entry).trim())
+      .filter(Boolean)
+      .map(normalizeLineAllowFrom),
+});