@kodelyth/line 2026.5.42 → 2026.6.2

package/src/setup-surface.test.ts

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

@@ -1,229 +0,0 @@
-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),
-};