@kodelyth/line 2026.5.39 → 2026.5.42

package/src/setup-surface.test.ts

@@ -0,0 +1,481 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { createStartAccountContext } from "klaw/plugin-sdk/channel-test-helpers";
+import {
+  createPluginSetupWizardConfigure,
+  createTestWizardPrompter,
+  runSetupWizardConfigure,
+} from "klaw/plugin-sdk/plugin-test-runtime";
+import type { WizardPrompter } from "klaw/plugin-sdk/plugin-test-runtime";
+import { bundledPluginRoot } from "klaw/plugin-sdk/test-fixtures";
+import ts from "typescript";
+import { afterAll, afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { KlawConfig, PluginRuntime, ResolvedLineAccount } from "../api.js";
+import { linePlugin } from "./channel.js";
+import { lineGatewayAdapter } from "./gateway.js";
+import { probeLineBot } from "./probe.js";
+import { clearLineRuntime, setLineRuntime } from "./runtime.js";
+import { lineSetupWizard } from "./setup-surface.js";
+import { lineStatusAdapter } from "./status.js";
+
+const { getBotInfoMock, MessagingApiClientMock } = vi.hoisted(() => {
+  const getBotInfoMock = vi.fn();
+  const MessagingApiClientMock = vi.fn(function () {
+    return { getBotInfo: getBotInfoMock };
+  });
+  return { getBotInfoMock, MessagingApiClientMock };
+});
+
+vi.mock("@line/bot-sdk", () => ({
+  messagingApi: { MessagingApiClient: MessagingApiClientMock },
+}));
+
+afterAll(() => {
+  vi.doUnmock("@line/bot-sdk");
+  vi.resetModules();
+});
+
+const lineConfigure = createPluginSetupWizardConfigure(linePlugin);
+const LINE_SRC_PREFIX = `../../${bundledPluginRoot("line")}/src/`;
+
+function normalizeModuleSpecifier(specifier: string): string | null {
+  if (specifier.startsWith("./src/")) {
+    return specifier;
+  }
+  if (specifier.startsWith(LINE_SRC_PREFIX)) {
+    return `./src/${specifier.slice(LINE_SRC_PREFIX.length)}`;
+  }
+  return null;
+}
+
+function collectModuleExportNames(filePath: string): string[] {
+  const sourcePath = filePath.replace(/\.js$/, ".ts");
+  const sourceText = readFileSync(sourcePath, "utf8");
+  const sourceFile = ts.createSourceFile(sourcePath, sourceText, ts.ScriptTarget.Latest, true);
+  const names = new Set<string>();
+
+  for (const statement of sourceFile.statements) {
+    if (
+      ts.isExportDeclaration(statement) &&
+      statement.exportClause &&
+      ts.isNamedExports(statement.exportClause)
+    ) {
+      for (const element of statement.exportClause.elements) {
+        if (!element.isTypeOnly) {
+          names.add(element.name.text);
+        }
+      }
+      continue;
+    }
+
+    const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : undefined;
+    const isExported = modifiers?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword);
+    if (!isExported) {
+      continue;
+    }
+
+    if (ts.isVariableStatement(statement)) {
+      for (const declaration of statement.declarationList.declarations) {
+        if (ts.isIdentifier(declaration.name)) {
+          names.add(declaration.name.text);
+        }
+      }
+      continue;
+    }
+
+    if (
+      ts.isFunctionDeclaration(statement) ||
+      ts.isClassDeclaration(statement) ||
+      ts.isEnumDeclaration(statement)
+    ) {
+      if (statement.name) {
+        names.add(statement.name.text);
+      }
+    }
+  }
+
+  return Array.from(names).toSorted();
+}
+
+function collectRuntimeApiPreExports(runtimeApiPath: string): string[] {
+  const runtimeApiSource = readFileSync(runtimeApiPath, "utf8");
+  const runtimeApiFile = ts.createSourceFile(
+    runtimeApiPath,
+    runtimeApiSource,
+    ts.ScriptTarget.Latest,
+    true,
+  );
+  const preExports = new Set<string>();
+  let pluginSdkLineRuntimeSeen = false;
+  const removedLineRuntimeSpecifier = ["klaw", "plugin-sdk", "line-runtime"].join("/");
+
+  for (const statement of runtimeApiFile.statements) {
+    if (!ts.isExportDeclaration(statement)) {
+      continue;
+    }
+    const moduleSpecifier =
+      statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
+        ? statement.moduleSpecifier.text
+        : undefined;
+    if (!moduleSpecifier) {
+      continue;
+    }
+    if (moduleSpecifier === removedLineRuntimeSpecifier) {
+      pluginSdkLineRuntimeSeen = true;
+      break;
+    }
+    const normalized = normalizeModuleSpecifier(moduleSpecifier);
+    if (!normalized) {
+      continue;
+    }
+
+    if (!statement.exportClause) {
+      for (const name of collectModuleExportNames(
+        path.join(process.cwd(), "extensions", "line", normalized),
+      )) {
+        preExports.add(name);
+      }
+      continue;
+    }
+
+    if (!ts.isNamedExports(statement.exportClause)) {
+      continue;
+    }
+
+    for (const element of statement.exportClause.elements) {
+      if (!element.isTypeOnly) {
+        preExports.add(element.name.text);
+      }
+    }
+  }
+
+  if (!pluginSdkLineRuntimeSeen) {
+    return [];
+  }
+
+  return Array.from(preExports).toSorted();
+}
+
+describe("line setup wizard", () => {
+  it("configures token and secret for the default account", async () => {
+    const prompter = createTestWizardPrompter({
+      text: vi.fn(async ({ message }: { message: string }) => {
+        if (message === "Enter LINE channel access token") {
+          return "line-token";
+        }
+        if (message === "Enter LINE channel secret") {
+          return "line-secret";
+        }
+        throw new Error(`Unexpected prompt: ${message}`);
+      }) as WizardPrompter["text"],
+    });
+
+    const result = await runSetupWizardConfigure({
+      configure: lineConfigure,
+      cfg: {} as KlawConfig,
+      prompter,
+      options: {},
+    });
+
+    expect(result.accountId).toBe("default");
+    expect(result.cfg.channels?.line?.enabled).toBe(true);
+    expect(result.cfg.channels?.line?.channelAccessToken).toBe("line-token");
+    expect(result.cfg.channels?.line?.channelSecret).toBe("line-secret");
+  });
+
+  it("reads the named-account DM policy instead of the channel root", () => {
+    expect(
+      lineSetupWizard.dmPolicy?.getCurrent(
+        {
+          channels: {
+            line: {
+              dmPolicy: "disabled",
+              accounts: {
+                work: {
+                  channelAccessToken: "token",
+                  channelSecret: "secret",
+                  dmPolicy: "allowlist",
+                },
+              },
+            },
+          },
+        } as KlawConfig,
+        "work",
+      ),
+    ).toBe("allowlist");
+  });
+
+  it("reports account-scoped config keys for named accounts", () => {
+    expect(lineSetupWizard.dmPolicy?.resolveConfigKeys?.({} as KlawConfig, "work")).toEqual({
+      policyKey: "channels.line.accounts.work.dmPolicy",
+      allowFromKey: "channels.line.accounts.work.allowFrom",
+    });
+  });
+
+  it("uses configured defaultAccount for omitted DM policy account context", () => {
+    const cfg = {
+      channels: {
+        line: {
+          defaultAccount: "work",
+          dmPolicy: "disabled",
+          allowFrom: ["Uroot"],
+          accounts: {
+            work: {
+              channelAccessToken: "token",
+              channelSecret: "secret",
+              dmPolicy: "allowlist",
+            },
+          },
+        },
+      },
+    } as KlawConfig;
+
+    expect(lineSetupWizard.dmPolicy?.getCurrent(cfg)).toBe("allowlist");
+    expect(lineSetupWizard.dmPolicy?.resolveConfigKeys?.(cfg)).toEqual({
+      policyKey: "channels.line.accounts.work.dmPolicy",
+      allowFromKey: "channels.line.accounts.work.allowFrom",
+    });
+
+    const next = lineSetupWizard.dmPolicy?.setPolicy(cfg, "open");
+    const workAccount = next?.channels?.line?.accounts?.work as
+      | {
+          dmPolicy?: string;
+        }
+      | undefined;
+    expect(next?.channels?.line?.dmPolicy).toBe("disabled");
+    expect(workAccount?.dmPolicy).toBe("open");
+  });
+
+  it('writes open policy state to the named account and preserves inherited allowFrom with "*"', () => {
+    const next = lineSetupWizard.dmPolicy?.setPolicy(
+      {
+        channels: {
+          line: {
+            allowFrom: ["Uroot"],
+            accounts: {
+              work: {
+                channelAccessToken: "token",
+                channelSecret: "secret",
+              },
+            },
+          },
+        },
+      } as KlawConfig,
+      "open",
+      "work",
+    );
+
+    const workAccount = next?.channels?.line?.accounts?.work as
+      | {
+          dmPolicy?: string;
+          allowFrom?: string[];
+        }
+      | undefined;
+    expect(next?.channels?.line?.dmPolicy).toBeUndefined();
+    expect(next?.channels?.line?.allowFrom).toEqual(["Uroot"]);
+    expect(workAccount?.dmPolicy).toBe("open");
+    expect(workAccount?.allowFrom).toEqual(["Uroot", "*"]);
+  });
+
+  it("uses configured defaultAccount for omitted setup configured state", async () => {
+    const configured = await lineSetupWizard.status.resolveConfigured({
+      cfg: {
+        channels: {
+          line: {
+            defaultAccount: "work",
+            channelAccessToken: "root-token",
+            channelSecret: "root-secret",
+            accounts: {
+              alerts: {
+                channelAccessToken: "alerts-token",
+                channelSecret: "alerts-secret",
+              },
+              work: {
+                channelAccessToken: "",
+                channelSecret: "",
+              },
+            },
+          },
+        },
+      } as KlawConfig,
+    });
+
+    expect(configured).toBe(false);
+  });
+});
+
+describe("probeLineBot", () => {
+  beforeEach(() => {
+    getBotInfoMock.mockReset();
+    MessagingApiClientMock.mockReset();
+    MessagingApiClientMock.mockImplementation(function () {
+      return { getBotInfo: getBotInfoMock };
+    });
+  });
+
+  afterEach(() => {
+    clearLineRuntime();
+    vi.useRealTimers();
+    getBotInfoMock.mockClear();
+  });
+
+  it("returns timeout when bot info stalls", async () => {
+    vi.useFakeTimers();
+    getBotInfoMock.mockImplementation(() => new Promise(() => {}));
+
+    const probePromise = probeLineBot("token", 10);
+    await vi.advanceTimersByTimeAsync(20);
+    const result = await probePromise;
+
+    expect(result.ok).toBe(false);
+    expect(result.error).toBe("timeout");
+  });
+
+  it("returns bot info when available", async () => {
+    getBotInfoMock.mockResolvedValue({
+      displayName: "Klaw",
+      userId: "U123",
+      basicId: "@klaw",
+      pictureUrl: "https://example.com/bot.png",
+    });
+
+    const result = await probeLineBot("token", 50);
+
+    expect(result.ok).toBe(true);
+    expect(result.bot?.userId).toBe("U123");
+  });
+});
+
+describe("linePlugin status.probeAccount", () => {
+  it("falls back to the direct probe helper when runtime is not initialized", async () => {
+    MessagingApiClientMock.mockReset();
+    MessagingApiClientMock.mockImplementation(function () {
+      return { getBotInfo: getBotInfoMock };
+    });
+    getBotInfoMock.mockResolvedValue({
+      displayName: "Klaw",
+      userId: "U123",
+      basicId: "@klaw",
+      pictureUrl: "https://example.com/bot.png",
+    });
+
+    const params = {
+      cfg: {} as KlawConfig,
+      account: {
+        accountId: "default",
+        enabled: true,
+        channelAccessToken: "token",
+        channelSecret: "secret",
+        tokenSource: "config",
+      } as ResolvedLineAccount,
+      timeoutMs: 50,
+    };
+
+    clearLineRuntime();
+
+    await expect(lineStatusAdapter.probeAccount!(params)).resolves.toEqual(
+      await probeLineBot("token", 50),
+    );
+  });
+});
+
+describe("line runtime api", () => {
+  it("keeps the LINE runtime barrel self-contained", () => {
+    const runtimeApiPath = path.join(process.cwd(), "extensions", "line", "runtime-api.ts");
+    expect(collectRuntimeApiPreExports(runtimeApiPath)).toStrictEqual([]);
+    expect(collectRuntimeApiPreExports(runtimeApiPath)).toStrictEqual([]);
+  });
+});
+
+function createRuntime() {
+  const monitorLineProvider = vi.fn(
+    async (_opts: { accountId?: string; channelAccessToken: string; channelSecret: string }) => ({
+      account: { accountId: "default" },
+      handleWebhook: async () => {},
+      stop: () => {},
+    }),
+  );
+
+  const runtime = {
+    channel: {
+      line: {
+        monitorLineProvider,
+      },
+    },
+    logging: {
+      shouldLogVerbose: () => false,
+    },
+  } as unknown as PluginRuntime;
+
+  return { runtime, monitorLineProvider };
+}
+
+function createAccount(params: { token: string; secret: string }): ResolvedLineAccount {
+  return {
+    accountId: "default",
+    enabled: true,
+    channelAccessToken: params.token,
+    channelSecret: params.secret,
+    tokenSource: "config",
+    config: {} as ResolvedLineAccount["config"],
+  };
+}
+
+function startLineAccount(params: { account: ResolvedLineAccount; abortSignal?: AbortSignal }) {
+  const { runtime, monitorLineProvider } = createRuntime();
+  setLineRuntime(runtime);
+  return {
+    monitorLineProvider,
+    task: lineGatewayAdapter.startAccount!(
+      createStartAccountContext({
+        account: params.account,
+        abortSignal: params.abortSignal,
+      }),
+    ),
+  };
+}
+
+describe("linePlugin gateway.startAccount", () => {
+  it("fails startup when channel secret is missing", async () => {
+    const { monitorLineProvider, task } = startLineAccount({
+      account: createAccount({ token: "token", secret: "   " }),
+    });
+
+    await expect(task).rejects.toThrow(
+      'LINE webhook mode requires a non-empty channel secret for account "default".',
+    );
+    expect(monitorLineProvider).not.toHaveBeenCalled();
+  });
+
+  it("fails startup when channel access token is missing", async () => {
+    const { monitorLineProvider, task } = startLineAccount({
+      account: createAccount({ token: "   ", secret: "secret" }),
+    });
+
+    await expect(task).rejects.toThrow(
+      'LINE webhook mode requires a non-empty channel access token for account "default".',
+    );
+    expect(monitorLineProvider).not.toHaveBeenCalled();
+  });
+
+  it("starts provider when token and secret are present", async () => {
+    const abort = new AbortController();
+    const { monitorLineProvider, task } = startLineAccount({
+      account: createAccount({ token: "token", secret: "secret" }),
+      abortSignal: abort.signal,
+    });
+
+    await vi.waitFor(() => {
+      expect(monitorLineProvider).toHaveBeenCalledTimes(1);
+    });
+    const startupParams = (monitorLineProvider.mock.calls as unknown[][])[0]?.[0] as
+      | { accountId?: string; channelAccessToken?: string; channelSecret?: string }
+      | undefined;
+    expect(startupParams?.channelAccessToken).toBe("token");
+    expect(startupParams?.channelSecret).toBe("secret");
+    expect(startupParams?.accountId).toBe("default");
+
+    abort.abort();
+    await task;
+  });
+});

package/src/setup-surface.ts

@@ -0,0 +1,229 @@
+import {
+  createAllowFromSection,
+  createStandardChannelSetupStatus,
+  mergeAllowFromEntries,
+  createSetupTranslator,
+} from "klaw/plugin-sdk/setup";
+import { normalizeOptionalString } from "klaw/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),
+};