@kodelyth/line 2026.5.42 → 2026.6.1

package/src/accounts.test.ts

@@ -1,288 +0,0 @@
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import type { KlawConfig } from "klaw/plugin-sdk/config-contracts";
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import {
-  resolveLineAccount,
-  resolveDefaultLineAccountId,
-  normalizeAccountId,
-  DEFAULT_ACCOUNT_ID,
-} from "./accounts.js";
-
-describe("LINE accounts", () => {
-  const tempDirs: string[] = [];
-
-  const createSecretFile = (fileName: string, contents: string) => {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), "klaw-line-account-"));
-    tempDirs.push(dir);
-    const filePath = path.join(dir, fileName);
-    fs.writeFileSync(filePath, contents, "utf8");
-    return filePath;
-  };
-
-  beforeEach(() => {
-    vi.stubEnv("LINE_CHANNEL_ACCESS_TOKEN", "");
-    vi.stubEnv("LINE_CHANNEL_SECRET", "");
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-    for (const dir of tempDirs.splice(0)) {
-      fs.rmSync(dir, { recursive: true, force: true });
-    }
-  });
-
-  describe("resolveLineAccount", () => {
-    it("resolves account from config", () => {
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            enabled: true,
-            channelAccessToken: "test-token",
-            channelSecret: "test-secret",
-            name: "Test Bot",
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg });
-
-      expect(account.accountId).toBe(DEFAULT_ACCOUNT_ID);
-      expect(account.enabled).toBe(true);
-      expect(account.channelAccessToken).toBe("test-token");
-      expect(account.channelSecret).toBe("test-secret");
-      expect(account.name).toBe("Test Bot");
-      expect(account.tokenSource).toBe("config");
-    });
-
-    it("resolves account from environment variables", () => {
-      vi.stubEnv("LINE_CHANNEL_ACCESS_TOKEN", "env-token");
-      vi.stubEnv("LINE_CHANNEL_SECRET", "env-secret");
-
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            enabled: true,
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg });
-
-      expect(account.channelAccessToken).toBe("env-token");
-      expect(account.channelSecret).toBe("env-secret");
-      expect(account.tokenSource).toBe("env");
-    });
-
-    it("resolves named account", () => {
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            enabled: true,
-            accounts: {
-              business: {
-                enabled: true,
-                channelAccessToken: "business-token",
-                channelSecret: "business-secret",
-                name: "Business Bot",
-              },
-            },
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg, accountId: "business" });
-
-      expect(account.accountId).toBe("business");
-      expect(account.enabled).toBe(true);
-      expect(account.channelAccessToken).toBe("business-token");
-      expect(account.channelSecret).toBe("business-secret");
-      expect(account.name).toBe("Business Bot");
-    });
-
-    it("uses configured defaultAccount when accountId is omitted", () => {
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            defaultAccount: "business",
-            accounts: {
-              business: {
-                enabled: true,
-                channelAccessToken: "business-token",
-                channelSecret: "business-secret",
-                name: "Business Bot",
-              },
-            },
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg });
-
-      expect(account.accountId).toBe("business");
-      expect(account.enabled).toBe(true);
-      expect(account.channelAccessToken).toBe("business-token");
-      expect(account.channelSecret).toBe("business-secret");
-      expect(account.name).toBe("Business Bot");
-    });
-
-    it("returns empty token when not configured", () => {
-      const cfg: KlawConfig = {};
-
-      const account = resolveLineAccount({ cfg });
-
-      expect(account.channelAccessToken).toBe("");
-      expect(account.channelSecret).toBe("");
-      expect(account.tokenSource).toBe("none");
-    });
-
-    it("resolves default account credentials from files", () => {
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            tokenFile: createSecretFile("token.txt", "file-token\n"),
-            secretFile: createSecretFile("secret.txt", "file-secret\n"),
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg });
-
-      expect(account.channelAccessToken).toBe("file-token");
-      expect(account.channelSecret).toBe("file-secret");
-      expect(account.tokenSource).toBe("file");
-    });
-
-    it("resolves named account credentials from account-level files", () => {
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            accounts: {
-              business: {
-                tokenFile: createSecretFile("business-token.txt", "business-file-token\n"),
-                secretFile: createSecretFile("business-secret.txt", "business-file-secret\n"),
-              },
-            },
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg, accountId: "business" });
-
-      expect(account.channelAccessToken).toBe("business-file-token");
-      expect(account.channelSecret).toBe("business-file-secret");
-      expect(account.tokenSource).toBe("file");
-    });
-
-    it.runIf(process.platform !== "win32")("rejects symlinked token and secret files", () => {
-      const dir = fs.mkdtempSync(path.join(os.tmpdir(), "klaw-line-account-"));
-      tempDirs.push(dir);
-      const tokenFile = path.join(dir, "token.txt");
-      const tokenLink = path.join(dir, "token-link.txt");
-      const secretFile = path.join(dir, "secret.txt");
-      const secretLink = path.join(dir, "secret-link.txt");
-      fs.writeFileSync(tokenFile, "file-token\n", "utf8");
-      fs.writeFileSync(secretFile, "file-secret\n", "utf8");
-      fs.symlinkSync(tokenFile, tokenLink);
-      fs.symlinkSync(secretFile, secretLink);
-
-      const cfg: KlawConfig = {
-        channels: {
-          line: {
-            tokenFile: tokenLink,
-            secretFile: secretLink,
-          },
-        },
-      };
-
-      const account = resolveLineAccount({ cfg });
-      expect(account.channelAccessToken).toBe("");
-      expect(account.channelSecret).toBe("");
-      expect(account.tokenSource).toBe("none");
-    });
-  });
-
-  describe("resolveDefaultLineAccountId", () => {
-    it.each([
-      {
-        name: "prefers channels.line.defaultAccount when configured",
-        cfg: {
-          channels: {
-            line: {
-              defaultAccount: "business",
-              accounts: {
-                business: { enabled: true },
-                support: { enabled: true },
-              },
-            },
-          },
-        } satisfies KlawConfig,
-        expected: "business",
-      },
-      {
-        name: "normalizes channels.line.defaultAccount before lookup",
-        cfg: {
-          channels: {
-            line: {
-              defaultAccount: "Business Ops",
-              accounts: {
-                "business-ops": { enabled: true },
-              },
-            },
-          },
-        } satisfies KlawConfig,
-        expected: "business-ops",
-      },
-      {
-        name: "returns first named account when default not configured",
-        cfg: {
-          channels: {
-            line: {
-              accounts: {
-                business: { enabled: true },
-              },
-            },
-          },
-        } satisfies KlawConfig,
-        expected: "business",
-      },
-      {
-        name: "falls back when channels.line.defaultAccount is missing",
-        cfg: {
-          channels: {
-            line: {
-              defaultAccount: "missing",
-              accounts: {
-                business: { enabled: true },
-              },
-            },
-          },
-        } satisfies KlawConfig,
-        expected: "business",
-      },
-      {
-        name: "prefers the default account when base credentials are configured",
-        cfg: {
-          channels: {
-            line: {
-              channelAccessToken: "base-token",
-              accounts: {
-                business: { enabled: true },
-              },
-            },
-          },
-        } satisfies KlawConfig,
-        expected: DEFAULT_ACCOUNT_ID,
-      },
-    ])("$name", ({ cfg, expected }) => {
-      expect(resolveDefaultLineAccountId(cfg)).toBe(expected);
-    });
-  });
-
-  describe("normalizeAccountId", () => {
-    it("trims and lowercases account ids", () => {
-      expect(normalizeAccountId("  Business  ")).toBe("business");
-    });
-  });
-});

package/src/accounts.ts

@@ -1,187 +0,0 @@
-import {
-  DEFAULT_ACCOUNT_ID,
-  normalizeAccountId as normalizeSharedAccountId,
-  normalizeOptionalAccountId,
-} from "klaw/plugin-sdk/account-id";
-import type { KlawConfig } from "klaw/plugin-sdk/account-resolution";
-import { resolveAccountEntry } from "klaw/plugin-sdk/account-resolution";
-import { tryReadSecretFileSync } from "klaw/plugin-sdk/core";
-import type {
-  LineAccountConfig,
-  LineConfig,
-  LineTokenSource,
-  ResolvedLineAccount,
-} from "./types.js";
-
-export { DEFAULT_ACCOUNT_ID } from "klaw/plugin-sdk/account-id";
-
-function readFileIfExists(filePath: string | undefined): string | undefined {
-  return tryReadSecretFileSync(filePath, "LINE credential file", { rejectSymlink: true });
-}
-
-function resolveToken(params: {
-  accountId: string;
-  baseConfig?: LineConfig;
-  accountConfig?: LineAccountConfig;
-}): { token: string; tokenSource: LineTokenSource } {
-  const { accountId, baseConfig, accountConfig } = params;
-
-  if (accountConfig?.channelAccessToken?.trim()) {
-    return { token: accountConfig.channelAccessToken.trim(), tokenSource: "config" };
-  }
-
-  const accountFileToken = readFileIfExists(accountConfig?.tokenFile);
-  if (accountFileToken) {
-    return { token: accountFileToken, tokenSource: "file" };
-  }
-
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    if (baseConfig?.channelAccessToken?.trim()) {
-      return { token: baseConfig.channelAccessToken.trim(), tokenSource: "config" };
-    }
-
-    const baseFileToken = readFileIfExists(baseConfig?.tokenFile);
-    if (baseFileToken) {
-      return { token: baseFileToken, tokenSource: "file" };
-    }
-
-    const envToken = process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim();
-    if (envToken) {
-      return { token: envToken, tokenSource: "env" };
-    }
-  }
-
-  return { token: "", tokenSource: "none" };
-}
-
-function resolveSecret(params: {
-  accountId: string;
-  baseConfig?: LineConfig;
-  accountConfig?: LineAccountConfig;
-}): string {
-  const { accountId, baseConfig, accountConfig } = params;
-
-  if (accountConfig?.channelSecret?.trim()) {
-    return accountConfig.channelSecret.trim();
-  }
-
-  const accountFileSecret = readFileIfExists(accountConfig?.secretFile);
-  if (accountFileSecret) {
-    return accountFileSecret;
-  }
-
-  if (accountId === DEFAULT_ACCOUNT_ID) {
-    if (baseConfig?.channelSecret?.trim()) {
-      return baseConfig.channelSecret.trim();
-    }
-
-    const baseFileSecret = readFileIfExists(baseConfig?.secretFile);
-    if (baseFileSecret) {
-      return baseFileSecret;
-    }
-
-    const envSecret = process.env.LINE_CHANNEL_SECRET?.trim();
-    if (envSecret) {
-      return envSecret;
-    }
-  }
-
-  return "";
-}
-
-export function resolveLineAccount(params: {
-  cfg: KlawConfig;
-  accountId?: string;
-}): ResolvedLineAccount {
-  const cfg = params.cfg;
-  const accountId = normalizeSharedAccountId(params.accountId ?? resolveDefaultLineAccountId(cfg));
-  const lineConfig = cfg.channels?.line as LineConfig | undefined;
-  const accounts = lineConfig?.accounts;
-  const accountConfig =
-    accountId !== DEFAULT_ACCOUNT_ID ? resolveAccountEntry(accounts, accountId) : undefined;
-
-  const { token, tokenSource } = resolveToken({
-    accountId,
-    baseConfig: lineConfig,
-    accountConfig,
-  });
-
-  const secret = resolveSecret({
-    accountId,
-    baseConfig: lineConfig,
-    accountConfig,
-  });
-
-  const {
-    accounts: _ignoredAccounts,
-    defaultAccount: _ignoredDefaultAccount,
-    ...lineBase
-  } = (lineConfig ?? {}) as LineConfig & {
-    accounts?: unknown;
-    defaultAccount?: unknown;
-  };
-  const mergedConfig: LineConfig & LineAccountConfig = {
-    ...lineBase,
-    ...accountConfig,
-  };
-
-  const enabled =
-    accountConfig?.enabled ??
-    (accountId === DEFAULT_ACCOUNT_ID ? (lineConfig?.enabled ?? true) : false);
-
-  const name =
-    accountConfig?.name ?? (accountId === DEFAULT_ACCOUNT_ID ? lineConfig?.name : undefined);
-
-  return {
-    accountId,
-    name,
-    enabled,
-    channelAccessToken: token,
-    channelSecret: secret,
-    tokenSource,
-    config: mergedConfig,
-  };
-}
-
-export function listLineAccountIds(cfg: KlawConfig): string[] {
-  const lineConfig = cfg.channels?.line as LineConfig | undefined;
-  const accounts = lineConfig?.accounts;
-  const ids = new Set<string>();
-
-  if (
-    lineConfig?.channelAccessToken?.trim() ||
-    lineConfig?.tokenFile ||
-    process.env.LINE_CHANNEL_ACCESS_TOKEN?.trim()
-  ) {
-    ids.add(DEFAULT_ACCOUNT_ID);
-  }
-
-  if (accounts) {
-    for (const id of Object.keys(accounts)) {
-      ids.add(id);
-    }
-  }
-
-  return Array.from(ids);
-}
-
-export function resolveDefaultLineAccountId(cfg: KlawConfig): string {
-  const preferred = normalizeOptionalAccountId(
-    (cfg.channels?.line as LineConfig | undefined)?.defaultAccount,
-  );
-  if (
-    preferred &&
-    listLineAccountIds(cfg).some((accountId) => normalizeSharedAccountId(accountId) === preferred)
-  ) {
-    return preferred;
-  }
-  const ids = listLineAccountIds(cfg);
-  if (ids.includes(DEFAULT_ACCOUNT_ID)) {
-    return DEFAULT_ACCOUNT_ID;
-  }
-  return ids[0] ?? DEFAULT_ACCOUNT_ID;
-}
-
-export function normalizeAccountId(accountId: string | undefined): string {
-  return normalizeSharedAccountId(accountId);
-}

package/src/actions.ts

@@ -1,61 +0,0 @@
-import type { messagingApi } from "@line/bot-sdk";
-
-export type Action = messagingApi.Action;
-
-/**
- * Create a message action (sends text when tapped)
- */
-export function messageAction(label: string, text?: string): Action {
-  return {
-    type: "message",
-    label: label.slice(0, 20),
-    text: text ?? label,
-  };
-}
-
-/**
- * Create a URI action (opens a URL when tapped)
- */
-export function uriAction(label: string, uri: string): Action {
-  return {
-    type: "uri",
-    label: label.slice(0, 20),
-    uri,
-  };
-}
-
-/**
- * Create a postback action (sends data to webhook when tapped)
- */
-export function postbackAction(label: string, data: string, displayText?: string): Action {
-  return {
-    type: "postback",
-    label: label.slice(0, 20),
-    data: data.slice(0, 300),
-    displayText: displayText?.slice(0, 300),
-  };
-}
-
-/**
- * Create a datetime picker action
- */
-export function datetimePickerAction(
-  label: string,
-  data: string,
-  mode: "date" | "time" | "datetime",
-  options?: {
-    initial?: string;
-    max?: string;
-    min?: string;
-  },
-): Action {
-  return {
-    type: "datetimepicker",
-    label: label.slice(0, 20),
-    data: data.slice(0, 300),
-    mode,
-    initial: options?.initial,
-    max: options?.max,
-    min: options?.min,
-  };
-}