[OpenClaw 文档]消息渠道--消息平台

点击侧边栏中的 **Bot**。将 **Username** 设置为你给 OpenClaw 智能体起的名称。

- **Message Content Intent**（必需）
- **Server Members Intent**（推荐；角色允许列表和名称到 ID 匹配需要它）
- **Presence Intent**（可选；仅状态更新需要）

<Note>
尽管名称如此，这会生成你的第一个令牌，并没有任何内容被“重置”。
</Note>

复制该令牌并保存到某处。这是你的 **Bot Token**，稍后会用到。

向下滚动到 **OAuth2 URL Generator** 并启用：

- `bot`
- `applications.commands`

下方会出现 **Bot Permissions** 部分。至少启用：

**General Permissions**
  - 查看频道
**Text Permissions**
  - 发送消息
  - 读取消息历史
  - 嵌入链接
  - 附加文件
  - 添加回应（可选）

这是普通文本频道的基线权限集。如果你计划在 Discord 话题中发帖，包括创建或继续话题的论坛或媒体频道工作流，还要启用 **Send Messages in Threads**。
复制底部生成的 URL，将其粘贴到浏览器中，选择你的服务器，然后点击 **Continue** 进行连接。现在你应该能在 Discord 服务器中看到你的机器人。

1. 点击 **User Settings**（头像旁边的齿轮图标）→ **Advanced** → 打开 **Developer Mode**
2. 右键点击侧边栏中的 **服务器图标** → **Copy Server ID**
3. 右键点击你**自己的头像** → **Copy User ID**

将你的 **Server ID** 和 **User ID** 与 Bot Token 一起保存；下一步你会把这三项都发送给 OpenClaw。

这会允许服务器成员（包括机器人）向你发送私信。如果你想通过 Discord 私信使用 OpenClaw，请保持此项启用。如果你只计划使用服务器频道，可以在配对后禁用私信。

export DISCORD_BOT_TOKEN="YOUR_BOT_TOKEN"
cat > discord.patch.json5 <<'JSON5'
{
  channels: {
    discord: {
      enabled: true,
      token: { source: "env", provider: "default", id: "DISCORD_BOT_TOKEN" },
    },
  },
}
JSON5
openclaw config patch --file ./discord.patch.json5 --dry-run
openclaw config patch --file ./discord.patch.json5
openclaw gateway

如果 OpenClaw 已作为后台服务运行，请通过 OpenClaw Mac 应用重启它，或停止并重启 `openclaw gateway run` 进程。
对于托管服务安装，请在存在 `DISCORD_BOT_TOKEN` 的 shell 中运行 `openclaw gateway install`，或将该变量存储在 `~/.openclaw/.env` 中，这样服务在重启后就能解析 env SecretRef。
如果你的主机被 Discord 的启动应用查询阻止或限速，请从 Developer Portal 设置 Discord 应用/客户端 ID，以便启动时跳过该 REST 调用。默认账户使用 `channels.discord.applicationId`；运行多个 Discord 机器人时，使用 `channels.discord.accounts.<accountId>.applicationId`。

<Tabs>
  <Tab title="询问你的智能体">
    在任何现有渠道（例如 Telegram）中与你的 OpenClaw 智能体聊天并告诉它。如果 Discord 是你的第一个渠道，请改用 CLI / 配置标签页。

    > “我已经在配置中设置了 Discord 机器人令牌。请使用 User ID `<user_id>` 和 Server ID `<server_id>` 完成 Discord 设置。”
  </Tab>
  <Tab title="CLI / 配置">
    如果你更喜欢基于文件的配置，请设置：

{
  channels: {
    discord: {
      enabled: true,
      token: {
        source: "env",
        provider: "default",
        id: "DISCORD_BOT_TOKEN",
      },
    },
  },
}

    默认账户的环境变量回退：

DISCORD_BOT_TOKEN=...

    对于脚本化或远程设置，请使用 `openclaw config patch --file ./discord.patch.json5 --dry-run` 写入同一个 JSON5 块，然后在不带 `--dry-run` 的情况下重新运行。支持明文 `token` 值。对于 `channels.discord.token`，也支持跨 env/file/exec 提供商的 SecretRef 值。参见[密钥管理](/zh-CN/gateway/secrets)。

    对于多个 Discord 机器人，请将每个机器人令牌和应用 ID 放在各自账户下。顶层 `channels.discord.applicationId` 会被账户继承，因此只有在每个账户都应使用同一个应用 ID 时，才在那里设置它。

{
  channels: {
    discord: {
      enabled: true,
      accounts: {
        personal: {
          token: { source: "env", provider: "default", id: "DISCORD_PERSONAL_TOKEN" },
          applicationId: "111111111111111111",
        },
        work: {
          token: { source: "env", provider: "default", id: "DISCORD_WORK_TOKEN" },
          applicationId: "222222222222222222",
        },
      },
    },
  },
}

  </Tab>
</Tabs>

<Tabs>
  <Tab title="询问你的智能体">
    将配对码发送到现有渠道中的智能体：

    > “批准这个 Discord 配对码：`<CODE>`”
  </Tab>
  <Tab title="CLI">

openclaw pairing list discord
openclaw pairing approve discord <CODE>

  </Tab>
</Tabs>

配对码会在 1 小时后过期。

现在你应该可以通过私信在 Discord 中与你的智能体聊天。

<Tabs>
  <Tab title="询问你的智能体">
    > “将我的 Discord Server ID `<server_id>` 添加到服务器允许列表”
  </Tab>
  <Tab title="配置">

{
  channels: {
    discord: {
      groupPolicy: "allowlist",
      guilds: {
        YOUR_SERVER_ID: {
          requireMention: true,
          users: ["YOUR_USER_ID"],
        },
      },
    },
  },
}

  </Tab>
</Tabs>

在服务器频道中，普通助手最终回复默认保持私密。可见的 Discord 输出必须使用 `message` 工具显式发送，因此智能体默认可以旁观，并且只有在它判断频道回复有用时才发帖。

这意味着所选模型必须可靠地调用工具。如果 Discord 显示正在输入，日志也显示 token 用量，但没有发布消息，请检查会话日志中是否有带 `didSendViaMessagingTool: false` 的助手文本。这意味着模型生成了私密最终答案，而不是调用 `message(action=send)`。切换到更强的工具调用模型，或使用下面的配置恢复旧版自动最终回复。

<Tabs>
  <Tab title="询问你的智能体">
    > “允许我的智能体在此服务器上无需被 @mentioned 即可响应”
  </Tab>
  <Tab title="配置">
    在你的服务器配置中设置 `requireMention: false`：

{
  channels: {
    discord: {
      guilds: {
        YOUR_SERVER_ID: {
          requireMention: false,
        },
      },
    },
  },
}

    要为群组/频道房间恢复旧版自动最终回复，请设置 `messages.groupChat.visibleReplies: "automatic"`。

  </Tab>
</Tabs>

<Tabs>
  <Tab title="询问你的智能体">
    > “当我在 Discord 频道中提问时，如果你需要来自 MEMORY.md 的长期上下文，请使用 memory_search 或 memory_get。”
  </Tab>
  <Tab title="手动">
    如果你需要在每个频道中共享上下文，请将稳定指令放入 `AGENTS.md` 或 `USER.md`（它们会被注入每个会话）。将长期笔记保存在 `MEMORY.md` 中，并在需要时通过记忆工具访问它们。
  </Tab>
</Tabs>

openclaw message send --channel discord --target channel:<forumId> \
  --message "Topic title\nBody of the post"

openclaw message thread create --channel discord --target channel:<forumId> \
  --thread-name "Topic title" --message "Body of the post"

{
  channel: "discord",
  action: "send",
  to: "channel:123456789012345678",
  message: "Optional fallback text",
  components: {
    reusable: true,
    text: "Choose a path",
    blocks: [
      {
        type: "actions",
        buttons: [
          {
            label: "Approve",
            style: "success",
            allowedUsers: ["123456789012345678"],
          },
          { label: "Decline", style: "danger" },
        ],
      },
      {
        type: "actions",
        select: {
          type: "string",
          placeholder: "Pick an option",
          options: [
            { label: "Option A", value: "a" },
            { label: "Option B", value: "b" },
          ],
        },
      },
    ],
    modal: {
      title: "Details",
      triggerLabel: "Open form",
      fields: [
        { type: "text", label: "Requester" },
        {
          type: "select",
          label: "Priority",
          options: [
            { label: "Low", value: "low" },
            { label: "High", value: "high" },
          ],
        },
      ],
    },
  },
}

- `pairing`（默认）
- `allowlist`
- `open`（要求 `channels.discord.allowFrom` 包含 `"*"`）
- `disabled`

如果私信策略不是开放的，未知用户会被阻止（或在 `pairing` 模式下被提示进行配对）。

多账号优先级：

- `channels.discord.accounts.default.allowFrom` 仅适用于 `default` 账号。
- 对于单个账号，`allowFrom` 优先于旧版 `dm.allowFrom`。
- 当命名账号自己的 `allowFrom` 和旧版 `dm.allowFrom` 均未设置时，会继承 `channels.discord.allowFrom`。
- 命名账号不会继承 `channels.discord.accounts.default.allowFrom`。

旧版 `channels.discord.dm.policy` 和 `channels.discord.dm.allowFrom` 仍会读取以保持兼容。`openclaw doctor --fix` 会在不改变访问权限的前提下尽可能将它们迁移到 `dmPolicy` 和 `allowFrom`。

用于投递的私信目标格式：

- `user:<id>`
- `<@id>` 提及

当频道默认值处于活动状态时，裸数字 ID 通常会解析为频道 ID，但为了兼容性，列在账号有效私信 `allowFrom` 中的 ID 会被视为用户私信目标。

访问组名称会在消息渠道之间共享。对于成员以各渠道普通 `allowFrom` 语法表示的静态组，使用 `type: "message.senders"`；当 Discord 频道当前的 `ViewChannel` 受众应动态定义成员资格时，使用 `type: "discord.channelAudience"`。共享访问组行为记录在这里：[访问组](/zh-CN/channels/access-groups)。

{
  accessGroups: {
    operators: {
      type: "message.senders",
      members: {
        "*": ["global-owner-id"],
        discord: ["discord:123456789012345678"],
        telegram: ["987654321"],
      },
    },
  },
  channels: {
    discord: {
      dmPolicy: "allowlist",
      allowFrom: ["accessGroup:operators"],
    },
  },
}

Discord 文本频道没有单独的成员列表。`type: "discord.channelAudience"` 将成员资格建模为：私信发送者是配置服务器的成员，并且在应用角色和频道覆盖后，当前对配置频道拥有有效的 `ViewChannel` 权限。

示例：允许任何能看到 `#maintainers` 的人向机器人发送私信，同时对其他所有人关闭私信。

{
  accessGroups: {
    maintainers: {
      type: "discord.channelAudience",
      guildId: "1456350064065904867",
      channelId: "1456744319972282449",
      membership: "canViewChannel",
    },
  },
  channels: {
    discord: {
      dmPolicy: "allowlist",
      allowFrom: ["accessGroup:maintainers"],
    },
  },
}

你可以混合动态和静态条目：

{
  accessGroups: {
    maintainers: {
      type: "discord.channelAudience",
      guildId: "1456350064065904867",
      channelId: "1456744319972282449",
    },
  },
  channels: {
    discord: {
      dmPolicy: "allowlist",
      allowFrom: ["accessGroup:maintainers", "discord:123456789012345678"],
    },
  },
}

查询会失败即关闭。如果 Discord 返回 `Missing Access`、成员查询失败，或频道属于不同服务器，则该私信发送者会被视为未授权。

使用频道受众访问组时，请在 Discord Developer Portal 中为机器人启用 **Server Members Intent**。私信不包含服务器成员状态，因此 OpenClaw 会在授权时通过 Discord REST 解析成员。

- `open`
- `allowlist`
- `disabled`

存在 `channels.discord` 时，安全基线是 `allowlist`。

`allowlist` 行为：

- 服务器必须匹配 `channels.discord.guilds`（优先使用 `id`，也接受 slug）
- 可选发送者允许列表：`users`（推荐稳定 ID）和 `roles`（仅角色 ID）；如果配置了任一项，发送者匹配 `users` 或 `roles` 时会被允许
- 默认禁用直接名称/标签匹配；仅在破窗兼容模式下启用 `channels.discord.dangerouslyAllowNameMatching: true`
- `users` 支持名称/标签，但 ID 更安全；使用名称/标签条目时，`openclaw security audit` 会发出警告
- 如果服务器配置了 `channels`，未列出的频道会被拒绝
- 如果服务器没有 `channels` 块，则该允许列表服务器中的所有频道都会被允许

示例：

{
  channels: {
    discord: {
      groupPolicy: "allowlist",
      guilds: {
        "123456789012345678": {
          requireMention: true,
          ignoreOtherMentions: true,
          users: ["987654321098765432"],
          roles: ["123456789012345678"],
          channels: {
            general: { allow: true },
            help: { allow: true, requireMention: true },
          },
        },
      },
    },
  },
}

如果你只设置 `DISCORD_BOT_TOKEN`，但没有创建 `channels.discord` 块，则运行时回退为 `groupPolicy="allowlist"`（日志中会有警告），即使 `channels.defaults.groupPolicy` 是 `open`。

提及检测包括：

- 显式提及机器人
- 配置的提及模式（`agents.list[].groupChat.mentionPatterns`，回退到 `messages.groupChat.mentionPatterns`）
- 受支持情况下的隐式回复机器人行为

编写出站 Discord 消息时，使用规范的提及语法：用户使用 `<@USER_ID>`，频道使用 `<#CHANNEL_ID>`，角色使用 `<@&ROLE_ID>`。不要使用旧版 `<@!USER_ID>` 昵称提及形式。

`requireMention` 按服务器/频道配置（`channels.discord.guilds...`）。
`ignoreOtherMentions` 可选择丢弃提及其他用户/角色但未提及机器人的消息（不包括 @everyone/@here）。

群组私信：

- 默认：忽略（`dm.groupEnabled=false`）
- 可选允许列表通过 `dm.groupChannels` 设置（频道 ID 或 slug）

{
  bindings: [
    {
      agentId: "opus",
      match: {
        channel: "discord",
        guildId: "123456789012345678",
        roles: ["111111111111111111"],
      },
    },
    {
      agentId: "sonnet",
      match: {
        channel: "discord",
        guildId: "123456789012345678",
      },
    },
  ],
}

- `[[reply_to_current]]`
- `[[reply_to:<id>]]`

由 `channels.discord.replyToMode` 控制：

- `off`（默认）
- `first`
- `all`
- `batched`

注意：`off` 会禁用隐式回复线程。显式 `[[reply_to_*]]` 标签仍会被遵循。
`first` 始终会把隐式原生回复引用附加到该轮次的第一条出站 Discord 消息。
`batched` 仅在入站轮次是多条消息的防抖批处理时，才会附加 Discord 的隐式原生回复引用。这在你希望主要针对含义不明确的突发聊天使用原生回复，而不是每个单消息轮次都使用时很有用。

消息 ID 会在上下文/历史记录中暴露，以便智能体可以定位特定消息。

将 `channels.discord.streaming.mode` 设置为 `off` 可禁用 Discord 预览编辑。如果明确启用了 Discord 分块流式传输，OpenClaw 会跳过预览流，以避免重复流式传输。

{
  channels: {
    discord: {
      streaming: {
        mode: "progress",
        progress: {
          label: "auto",
          maxLines: 8,
          toolProgress: true,
        },
      },
    },
  },
}

- `partial` 会在令牌到达时编辑同一条预览消息。
- `block` 会发出草稿大小的分块（使用 `draftChunk` 调整大小和断点，并限制在 `textChunkLimit` 内）。
- 媒体、错误和显式回复的最终消息会取消待处理的预览编辑。
- `streaming.preview.toolProgress`（默认 `true`）控制工具/进度更新是否复用预览消息。
- 工具/进度行会在可用时渲染为紧凑的表情符号 + 标题 + 详情，例如 `🛠️ Bash: run tests` 或 `🔎 Web Search: for "query"`。
- `streaming.preview.commandText` / `streaming.progress.commandText` 控制紧凑进度行中的命令/执行详情：`raw`（默认）或 `status`（仅工具标签）。

隐藏原始命令/执行文本，同时保留紧凑进度行：

```json
{
  "channels": {
    "discord": {
      "streaming": {
        "mode": "progress",
        "progress": {
          "toolProgress": true,
          "commandText": "status"
        }
      }
    }
  }
}
```

预览流式传输仅支持文本；媒体回复会回退到正常投递。当明确启用 `block` 流式传输时，OpenClaw 会跳过预览流，以避免重复流式传输。

- `channels.discord.historyLimit` 默认 `20`
- 回退：`messages.groupChat.historyLimit`
- `0` 会禁用

私信历史记录控制：

- `channels.discord.dmHistoryLimit`
- `channels.discord.dms["<user_id>"].historyLimit`

线程行为：

- Discord 线程会作为渠道会话路由，并继承父渠道配置，除非被覆盖。
- 线程会话会继承父渠道的会话级 `/model` 选择，作为仅模型回退；线程本地 `/model` 选择仍优先，且父转录历史不会被复制，除非启用了转录继承。
- `channels.discord.thread.inheritParent`（默认 `false`）会让新的自动线程从父转录播种。按账号覆盖位于 `channels.discord.accounts.<id>.thread.inheritParent` 下。
- 消息工具反应可以解析 `user:<id>` 私信目标。
- `guilds.<guild>.channels.<channel>.requireMention: false` 会在回复阶段激活回退期间保留。

渠道主题会作为**不受信任的**上下文注入。允许列表用于限制谁可以触发智能体，而不是完整的补充上下文脱敏边界。

命令：

- `/focus <target>` 将当前/新线程绑定到子智能体/会话目标
- `/unfocus` 移除当前线程绑定
- `/agents` 显示活动运行和绑定状态
- `/session idle <duration|off>` 查看/更新已聚焦绑定的不活动自动取消聚焦
- `/session max-age <duration|off>` 查看/更新已聚焦绑定的硬性最大存续时间

配置：

{
  session: {
    threadBindings: {
      enabled: true,
      idleHours: 24,
      maxAgeHours: 0,
    },
  },
  channels: {
    discord: {
      threadBindings: {
        enabled: true,
        idleHours: 24,
        maxAgeHours: 0,
        spawnSessions: true,
        defaultSpawnContext: "fork",
      },
    },
  },
}

注意：

- `session.threadBindings.*` 设置全局默认值。
- `channels.discord.threadBindings.*` 覆盖 Discord 行为。
- `spawnSessions` 控制通过 `sessions_spawn({ thread: true })` 和 ACP 线程生成来自动创建/绑定线程。默认：`true`。
- `defaultSpawnContext` 控制线程绑定生成的原生子智能体上下文。默认：`"fork"`。
- 已弃用的 `spawnSubagentSessions`/`spawnAcpSessions` 键会由 `openclaw doctor --fix` 迁移。
- 如果账号禁用了线程绑定，`/focus` 和相关线程绑定操作将不可用。

请参阅[子智能体](/zh-CN/tools/subagents)、[ACP Agents](/zh-CN/tools/acp-agents) 和[配置参考](/zh-CN/gateway/configuration-reference)。

配置路径：

- `bindings[]`，带有 `type: "acp"` 和 `match.channel: "discord"`

示例：

{
  agents: {
    list: [
      {
        id: "codex",
        runtime: {
          type: "acp",
          acp: {
            agent: "codex",
            backend: "acpx",
            mode: "persistent",
            cwd: "/workspace/openclaw",
          },
        },
      },
    ],
  },
  bindings: [
    {
      type: "acp",
      agentId: "codex",
      match: {
        channel: "discord",
        accountId: "default",
        peer: { kind: "channel", id: "222222222222222222" },
      },
      acp: { label: "codex-main" },
    },
  ],
  channels: {
    discord: {
      guilds: {
        "111111111111111111": {
          channels: {
            "222222222222222222": {
              requireMention: false,
            },
          },
        },
      },
    },
  },
}

注意：

- `/acp spawn codex --bind here` 会在原位置绑定当前渠道或线程，并让未来消息保持在同一 ACP 会话上。线程消息会继承父渠道绑定。
- 在已绑定渠道或线程中，`/new` 和 `/reset` 会在原位置重置同一 ACP 会话。临时线程绑定可以在活动期间覆盖目标解析。
- `spawnSessions` 通过 `--thread auto|here` 控制子线程创建/绑定。

请参阅 [ACP Agents](/zh-CN/tools/acp-agents)，了解绑定行为详情。

- `off`
- `own`（默认）
- `all`
- `allowlist`（使用 `guilds.<id>.users`）

反应事件会被转换为系统事件，并附加到路由后的 Discord 会话。

解析顺序：

- `channels.discord.accounts.<accountId>.ackReaction`
- `channels.discord.ackReaction`
- `messages.ackReaction`
- 智能体身份表情符号回退（`agents.list[].identity.emoji`，否则为 "👀"）

注意：

- Discord 接受 unicode 表情符号或自定义表情符号名称。
- 使用 `""` 可禁用渠道或账号的反应。

这会影响 `/config set|unset` 流程（当命令功能启用时）。

禁用：

{
  channels: {
    discord: {
      configWrites: false,
    },
  },
}

{
  channels: {
    discord: {
      proxy: "http://proxy.example:8080",
    },
  },
}

按账号覆盖：

{
  channels: {
    discord: {
      accounts: {
        primary: {
          proxy: "http://proxy.example:8080",
        },
      },
    },
  },
}

{
  channels: {
    discord: {
      pluralkit: {
        enabled: true,
        token: "pk_live_...", // optional; needed for private systems
      },
    },
  },
}

注意：

- 允许列表可以使用 `pk:<memberId>`
- 仅当 `channels.discord.dangerouslyAllowNameMatching: true` 时，成员显示名称才会按名称/slug 匹配
- 查询使用原始消息 ID，并受时间窗口约束
- 如果查询失败，代理消息会被视为机器人消息并丢弃，除非 `allowBots=true`

{
  channels: {
    discord: {
      mentionAliases: {
        Vladislava: "123456789012345678",
      },
      accounts: {
        ops: {
          mentionAliases: {
            OpsLead: "234567890123456789",
          },
        },
      },
    },
  },
}

仅状态示例：

{
  channels: {
    discord: {
      status: "idle",
    },
  },
}

活动示例（自定义状态是默认活动类型）：

{
  channels: {
    discord: {
      activity: "Focus time",
      activityType: 4,
    },
  },
}

流式传输示例：

{
  channels: {
    discord: {
      activity: "Live coding",
      activityType: 1,
      activityUrl: "https://twitch.tv/openclaw",
    },
  },
}

活动类型映射：

- 0: 正在玩
- 1: 直播（需要 `activityUrl`）
- 2: 正在听
- 3: 正在观看
- 4: 自定义（使用活动文本作为状态 state；emoji 可选）
- 5: 正在竞赛

自动在线状态示例（运行时健康信号）：

{
  channels: {
    discord: {
      autoPresence: {
        enabled: true,
        intervalMs: 30000,
        minUpdateIntervalMs: 15000,
        exhaustedText: "token exhausted",
      },
    },
  },
}

自动在线状态会将运行时可用性映射到 Discord Status：healthy => online，degraded 或 unknown => idle，exhausted 或 unavailable => dnd。可选文本覆盖项：

- `autoPresence.healthyText`
- `autoPresence.degradedText`
- `autoPresence.exhaustedText`（支持 `{reason}` 占位符）

配置路径：

- `channels.discord.execApprovals.enabled`
- `channels.discord.execApprovals.approvers`（可选；可行时回退到 `commands.ownerAllowFrom`）
- `channels.discord.execApprovals.target`（`dm` | `channel` | `both`，默认值：`dm`）
- `agentFilter`、`sessionFilter`、`cleanupAfterResolve`

当 `enabled` 未设置或为 `"auto"`，并且至少可以从 `execApprovals.approvers` 或 `commands.ownerAllowFrom` 解析出一个批准者时，Discord 会自动启用原生 exec 批准。Discord 不会从渠道 `allowFrom`、旧版 `dm.allowFrom` 或直接消息 `defaultTo` 推断 exec 批准者。设置 `enabled: false` 可显式禁用 Discord 作为原生批准客户端。

对于 `/diagnostics` 和 `/export-trajectory` 等敏感的仅所有者群组命令，OpenClaw 会私下发送批准提示和最终结果。当调用命令的所有者有 Discord 所有者路由时，它会优先尝试 Discord 私信；如果不可用，则回退到 `commands.ownerAllowFrom` 中第一个可用的所有者路由，例如 Telegram。

当 `target` 为 `channel` 或 `both` 时，批准提示会在渠道中可见。只有已解析的批准者可以使用按钮；其他用户会收到临时拒绝。批准提示会包含命令文本，因此仅应在受信任渠道中启用渠道投递。如果无法从会话键推导出渠道 ID，OpenClaw 会回退到私信投递。

Discord 还会渲染其他聊天渠道使用的共享批准按钮。原生 Discord 适配器主要添加批准者私信路由和渠道扇出。
当这些按钮存在时，它们就是主要批准 UX；OpenClaw
仅应在工具结果表示
聊天批准不可用或手动批准是唯一路径时，才包含手动 `/approve` 命令。
如果 Discord 原生批准运行时未激活，OpenClaw 会保留
本地确定性的 `/approve <id> <decision>` 提示可见。如果
运行时已激活，但原生卡片无法投递到任何目标，
OpenClaw 会在同一聊天中发送回退通知，其中包含待处理批准里的确切 `/approve`
命令。

Gateway 网关身份验证和批准解析遵循共享 Gateway 网关客户端契约（`plugin:` ID 通过 `plugin.approval.resolve` 解析；其他 ID 通过 `exec.approval.resolve` 解析）。批准默认在 30 分钟后过期。

参见 [Exec 批准](/zh-CN/tools/exec-approvals)。

{
  channels: {
    discord: {
      ui: {
        components: {
          accentColor: "#5865F2",
        },
      },
    },
  },
}

/vc join channel:<voice-channel-id>
/vc status
/vc leave

openclaw channels capabilities --channel discord --target channel:<voice-channel-id>

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        model: "openai-codex/gpt-5.5",
        autoJoin: [
          {
            guildId: "123456789012345678",
            channelId: "234567890123456789",
          },
        ],
        allowedChannels: [
          {
            guildId: "123456789012345678",
            channelId: "234567890123456789",
          },
        ],
        daveEncryption: true,
        decryptionFailureTolerance: 24,
        connectTimeoutMs: 30000,
        reconnectGraceMs: 15000,
        realtime: {
          provider: "openai",
          model: "gpt-realtime-2",
          voice: "cedar",
        },
      },
    },
  },
}

pnpm install
mise exec node@22 -- pnpm discord:opus:install

OPENCLAW_DISCORD_OPUS_DECODER=native pnpm gateway:watch

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        model: "openai-codex/gpt-5.5",
        realtime: {
          provider: "openai",
          model: "gpt-realtime-2",
          voice: "cedar",
        },
      },
    },
  },
}

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        mode: "stt-tts",
        model: "openai/gpt-5.4-mini",
        tts: {
          provider: "openai",
          openai: {
            model: "gpt-4o-mini-tts",
            voice: "cedar",
          },
        },
      },
    },
  },
}

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        mode: "bidi",
        model: "openai-codex/gpt-5.5",
        realtime: {
          provider: "openai",
          model: "gpt-realtime-2",
          voice: "cedar",
          toolPolicy: "safe-read-only",
          consultPolicy: "always",
        },
      },
    },
  },
}

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        mode: "agent-proxy",
        model: "openai-codex/gpt-5.5",
        agentSession: {
          mode: "target",
          target: "channel:123456789012345678",
        },
        realtime: {
          provider: "openai",
          model: "gpt-realtime-2",
          voice: "cedar",
        },
      },
    },
  },
}

{
  channels: {
    discord: {
      voice: {
        enabled: true,
        mode: "bidi",
        model: "openai-codex/gpt-5.5",
        realtime: {
          provider: "openai",
          model: "gpt-realtime-2",
          voice: "cedar",
          bargeIn: true,
          minBargeInAudioEndMs: 500,
          consultPolicy: "always",
          providers: {
            openai: {
              interruptResponseOnInputAudio: false,
            },
          },
        },
      },
    },
  },
}

message(action="send", channel="discord", target="channel:123", path="/path/to/audio.mp3", asVoice=true)

- 启用 Message Content Intent
- 当你依赖用户/成员解析时，启用 Server Members Intent
- 更改 intents 后重启 Gateway 网关

- 验证 `groupPolicy`
- 验证 `channels.discord.guilds` 下的服务器 allowlist
- 如果服务器 `channels` map 存在，则只允许列出的频道
- 验证 `requireMention` 行为和提及模式

有用检查：

openclaw doctor
openclaw channels status --probe
openclaw logs --follow

- `groupPolicy="allowlist"`，但没有匹配的服务器/频道 allowlist
- `requireMention` 配置在错误的位置（必须位于 `channels.discord.guilds` 或频道条目下）
- 发送者被服务器/频道 `users` allowlist 阻止

典型日志：

- `Slow listener detected ...`
- `stuck session: sessionKey=agent:...:discord:... state=processing ...`

Discord Gateway 网关队列旋钮：

- 单账号：`channels.discord.eventQueue.listenerTimeout`
- 多账号：`channels.discord.accounts.<accountId>.eventQueue.listenerTimeout`
- 这只控制 Discord Gateway 网关监听器工作，不控制 agent 轮次生命周期

Discord 不会对排队的 agent 轮次应用频道拥有的超时。消息监听器会立即交接，排队的 Discord 运行会保留每个会话的顺序，直到会话/工具/运行时生命周期完成或中止工作。

{
  channels: {
    discord: {
      accounts: {
        default: {
          eventQueue: {
            listenerTimeout: 120000,
          },
        },
      },
    },
  },
}

元数据超时旋钮：

- 单账号：`channels.discord.gatewayInfoTimeoutMs`
- 多账号：`channels.discord.accounts.<accountId>.gatewayInfoTimeoutMs`
- 配置未设置时的环境变量回退：`OPENCLAW_DISCORD_GATEWAY_INFO_TIMEOUT_MS`
- 默认值：`30000`（30 秒），最大值：`120000`

READY 超时旋钮：

- 启动单账号：`channels.discord.gatewayReadyTimeoutMs`
- 启动多账号：`channels.discord.accounts.<accountId>.gatewayReadyTimeoutMs`
- 配置未设置时的启动环境变量回退：`OPENCLAW_DISCORD_READY_TIMEOUT_MS`
- 启动默认值：`15000`（15 秒），最大值：`120000`
- 运行时单账号：`channels.discord.gatewayRuntimeReadyTimeoutMs`
- 运行时多账号：`channels.discord.accounts.<accountId>.gatewayRuntimeReadyTimeoutMs`
- 配置未设置时的运行时环境变量回退：`OPENCLAW_DISCORD_RUNTIME_READY_TIMEOUT_MS`
- 运行时默认值：`30000`（30 秒），最大值：`120000`

如果你使用 slug 键，运行时匹配仍可工作，但 probe 无法完整验证权限。

- 私信已禁用：`channels.discord.dm.enabled=false`
- 私信策略已禁用：`channels.discord.dmPolicy="disabled"`（旧版：`channels.discord.dm.policy`）
- 在 `pairing` 模式中等待配对批准

如果你设置了 `channels.discord.allowBots=true`，请使用严格的提及和允许列表规则，避免循环行为。
优先使用 `channels.discord.allowBots="mentions"`，以便只接收提及该 bot 的 bot 消息。

{
  channels: {
    discord: {
      accounts: {
        mantis: {
          // Mantis listens to other bots only when they mention her.
          allowBots: "mentions",
        },
        molty: {
          // Molty listens to all bot-authored Discord messages.
          allowBots: true,
          mentionAliases: {
            // Lets Molty write "@Mantis" and send a real Discord mention.
            Mantis: "MANTIS_DISCORD_USER_ID",
          },
        },
      },
    },
  },
}

- 保持 OpenClaw 为当前版本（`openclaw update`），确保 Discord 语音接收恢复逻辑可用
- 确认 `channels.discord.voice.daveEncryption=true`（默认）
- 从 `channels.discord.voice.decryptionFailureTolerance=24`（上游默认值）开始，仅在需要时调整
- 查看日志中的：
  - `discord voice: DAVE decrypt failures detected`
  - `discord voice: repeated decrypt failures; attempting rejoin`
- 如果自动重新加入后故障仍然持续，请收集日志，并与 [discord.js #11419](https://github.com/discordjs/discord.js/issues/11419) 和 [discord.js #11449](https://github.com/discordjs/discord.js/pull/11449) 中的上游 DAVE 接收历史进行对比

openclaw pairing list feishu
openclaw pairing approve feishu <CODE>

{
  channels: {
    feishu: {
      groupPolicy: "open",
    },
  },
}

{
  channels: {
    feishu: {
      groupPolicy: "open",
      requireMention: true,
    },
  },
}

{
  channels: {
    feishu: {
      groupPolicy: "allowlist",
      // Group IDs look like: oc_xxx
      groupAllowFrom: ["oc_xxx", "oc_yyy"],
    },
  },
}

{
  channels: {
    feishu: {
      groupPolicy: "allowlist",
      groups: {
        oc_xxx: {
          requireMention: false,
        },
      },
    },
  },
}

{
  channels: {
    feishu: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["oc_xxx"],
      groups: {
        oc_xxx: {
          // User open_ids look like: ou_xxx
          allowFrom: ["ou_user1", "ou_user2"],
        },
      },
    },
  },
}

openclaw logs --follow

openclaw pairing list feishu

{
  channels: {
    feishu: {
      defaultAccount: "main",
      accounts: {
        main: {
          appId: "cli_xxx",
          appSecret: "xxx",
          name: "Primary bot",
          tts: {
            providers: {
              openai: { voice: "shimmer" },
            },
          },
        },
        backup: {
          appId: "cli_yyy",
          appSecret: "yyy",
          name: "Backup bot",
          enabled: false,
        },
      },
    },
  },
}

{
  channels: {
    feishu: {
      streaming: true, // enable streaming card output (default: true)
      blockStreaming: true, // opt into completed-block streaming
    },
  },
}

{
  channels: {
    feishu: {
      typingIndicator: false,
      resolveSenderNames: false,
    },
  },
}

{
  agents: {
    list: [
      {
        id: "codex",
        runtime: {
          type: "acp",
          acp: {
            agent: "codex",
            backend: "acpx",
            mode: "persistent",
            cwd: "/workspace/openclaw",
          },
        },
      },
    ],
  },
  bindings: [
    {
      type: "acp",
      agentId: "codex",
      match: {
        channel: "feishu",
        accountId: "default",
        peer: { kind: "direct", id: "ou_1234567890" },
      },
    },
    {
      type: "acp",
      agentId: "codex",
      match: {
        channel: "feishu",
        accountId: "default",
        peer: { kind: "group", id: "oc_group_chat:topic:om_topic_root" },
      },
      acp: { label: "codex-feishu-topic" },
    },
  ],
}

/acp spawn codex --thread here

{
  agents: {
    list: [
      { id: "main" },
      { id: "agent-a", workspace: "/home/user/agent-a" },
      { id: "agent-b", workspace: "/home/user/agent-b" },
    ],
  },
  bindings: [
    {
      agentId: "agent-a",
      match: {
        channel: "feishu",
        peer: { kind: "direct", id: "ou_xxx" },
      },
    },
    {
      agentId: "agent-b",
      match: {
        channel: "feishu",
        peer: { kind: "group", id: "oc_zzz" },
      },
    },
  ],
}

openclaw plugins install @openclaw/googlechat

openclaw plugins install ./path/to/local/googlechat-plugin

your-domain.com {
    reverse_proxy /googlechat* localhost:18789
}

{
  channels: {
    googlechat: {
      enabled: true,
      serviceAccountFile: "/path/to/service-account.json",
      // or serviceAccountRef: { source: "file", provider: "filemain", id: "/channels/googlechat/serviceAccount" }
      audienceType: "app-url",
      audience: "https://gateway.example.com/googlechat",
      webhookPath: "/googlechat",
      botUser: "users/1234567890", // optional; helps mention detection
      dm: {
        policy: "pairing",
        allowFrom: ["users/1234567890"],
      },
      groupPolicy: "allowlist",
      groups: {
        "spaces/AAAA": {
          enabled: true,
          requireMention: true,
          users: ["users/1234567890"],
          systemPrompt: "Short answers only.",
        },
      },
      actions: { reactions: true },
      typingIndicator: "message",
      mediaMaxMb: 20,
    },
  },
}

status code: 405, reason phrase: HTTP error response: HTTP/1.1 405 Method Not Allowed

openclaw channels status
# Should show: Google Chat default: enabled, configured, ...

brew install steipete/tap/imsg
imsg rpc --help
imsg launch
openclaw channels status --probe

  </Step>

  <Step title="配置 OpenClaw">

{
  channels: {
    imessage: {
      enabled: true,
      cliPath: "/usr/local/bin/imsg",
      dbPath: "/Users/user/Library/Messages/chat.db",
    },
  },
}

  </Step>

  <Step title="启动 Gateway 网关">

openclaw gateway

  </Step>

  <Step title="批准首次私信配对（默认 dmPolicy）">

openclaw pairing list imessage
openclaw pairing approve imessage <CODE>

    配对请求会在 1 小时后过期。
  </Step>
</Steps>

#!/usr/bin/env bash
exec ssh -T gateway-host imsg "$@"

启用附件时的推荐配置：

{
  channels: {
    imessage: {
      enabled: true,
      cliPath: "~/.openclaw/scripts/imsg-ssh",
      remoteHost: "user@gateway-host", // used for SCP attachment fetches
      includeAttachments: true,
      // Optional: override allowed attachment roots.
      // Defaults include /Users/*/Library/Messages/Attachments
      attachmentRoots: ["/Users/*/Library/Messages/Attachments"],
      remoteAttachmentRoots: ["/Users/*/Library/Messages/Attachments"],
    },
  },
}

如果未设置 `remoteHost`，OpenClaw 会尝试通过解析 SSH 包装脚本来自动检测它。
`remoteHost` 必须是 `host` 或 `user@host`（不能包含空格或 SSH 选项）。
OpenClaw 对 SCP 使用严格的主机密钥检查，因此中继主机密钥必须已存在于 `~/.ssh/known_hosts` 中。
附件路径会根据允许的根路径（`attachmentRoots` / `remoteAttachmentRoots`）进行验证。

imsg chats --limit 1
# or
imsg send <handle> "test"

- `pairing`（默认）
- `allowlist`
- `open`（要求 `allowFrom` 包含 `"*"`）
- `disabled`

允许列表字段：`channels.imessage.allowFrom`。

允许列表条目必须标识发送者：handle 或静态发送者访问组（`accessGroup:<name>`）。对 `chat_id:*`、`chat_guid:*` 或 `chat_identifier:*` 等聊天目标使用 `channels.imessage.groupAllowFrom`；对数字 `chat_id` 注册表键使用 `channels.imessage.groups`。

- `allowlist`（配置时默认）
- `open`
- `disabled`

群组发送者允许列表：`channels.imessage.groupAllowFrom`。

`groupAllowFrom` 条目也可以引用静态发送者访问组（`accessGroup:<name>`）。

运行时回退：如果未设置 `groupAllowFrom`，iMessage 群组发送者检查会使用 `allowFrom`；当私信和群组准入应不同时，请设置 `groupAllowFrom`。
运行时说明：如果完全缺少 `channels.imessage`，运行时会回退到 `groupPolicy="allowlist"` 并记录警告（即使已设置 `channels.defaults.groupPolicy`）。

<Warning>
群组路由有**两个**连续运行的允许列表门控，并且两者都必须通过：

1. **发送者 / 聊天目标允许列表**（`channels.imessage.groupAllowFrom`）— handle、`chat_guid`、`chat_identifier` 或 `chat_id`。
2. **群组注册表**（`channels.imessage.groups`）— 使用 `groupPolicy: "allowlist"` 时，此门控需要 `groups: { "*": { ... } }` 通配符条目（设置 `allowAll = true`），或 `groups` 下显式的每个 `chat_id` 条目。

如果门控 2 中没有任何内容，每条群组消息都会被丢弃。插件会在默认日志级别发出两个 `warn` 级别信号：

- 启动时每个账号一次：`imessage: groupPolicy="allowlist" but channels.imessage.groups is empty for account "<id>"`
- 运行时每个 `chat_id` 一次：`imessage: dropping group message from chat_id=<id> ...`

私信会继续工作，因为它们走的是不同代码路径。

在 `groupPolicy: "allowlist"` 下保持群组继续流转的最低配置：

```json5
{
  channels: {
    imessage: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["+15555550123"],
      groups: { "*": { "requireMention": true } },
    },
  },
}
```

如果这些 `warn` 行出现在 Gateway 网关日志中，说明第 2 道门控正在丢弃消息 —— 添加 `groups` 块。
</Warning>

群组的提及门控：

- iMessage 没有原生提及元数据
- 提及检测使用正则表达式模式（`agents.list[].groupChat.mentionPatterns`，回退为 `messages.groupChat.mentionPatterns`）
- 未配置模式时，无法强制执行提及门控

来自已授权发送者的控制命令可以绕过群组中的提及门控。

按群组设置的 `systemPrompt`：

`channels.imessage.groups.*` 下的每个条目都接受一个可选的 `systemPrompt` 字符串。该值会在处理该群组消息的每个轮次中注入到智能体的系统提示词中。解析方式与 `channels.whatsapp.groups` 使用的按群组提示词解析一致：

1. **群组专用系统提示词**（`groups["<chat_id>"].systemPrompt`）：当映射中存在特定群组条目，**并且**定义了其 `systemPrompt` 键时使用。如果 `systemPrompt` 是空字符串（`""`），则会抑制通配符，并且不会对该群组应用系统提示词。
2. **群组通配符系统提示词**（`groups["*"].systemPrompt`）：当映射中完全不存在特定群组条目，或存在但未定义 `systemPrompt` 键时使用。

```json5
{
  channels: {
    imessage: {
      groupPolicy: "allowlist",
      groupAllowFrom: ["+15555550123"],
      groups: {
        "*": { systemPrompt: "Use British spelling." },
        "8421": {
          requireMention: true,
          systemPrompt: "This is the on-call rotation chat. Keep replies under 3 sentences.",
        },
        "9907": {
          // explicit suppression: the wildcard "Use British spelling." does not apply here
          systemPrompt: "",
        },
      },
    },
  },
}
```

按群组设置的提示词只应用于群组消息 —— 此频道中的私信不受影响。

类群组线程行为：

一些多参与者 iMessage 线程可能会以 `is_group=false` 到达。
如果该 `chat_id` 已在 `channels.imessage.groups` 下显式配置，OpenClaw 会将其视为群组流量（群组门控 + 群组会话隔离）。

{
  agents: {
    list: [
      {
        id: "codex",
        runtime: {
          type: "acp",
          acp: { agent: "codex", backend: "acpx", mode: "persistent" },
        },
      },
    ],
  },
  bindings: [
    {
      type: "acp",
      agentId: "codex",
      match: {
        channel: "imessage",
        accountId: "default",
        peer: { kind: "group", id: "chat_id:123" },
      },
      acp: { label: "codex-group" },
    },
  ],
}

典型流程：

1. 创建/登录专用 macOS 用户。
2. 在该用户中使用机器人 Apple ID 登录 Messages。
3. 在该用户中安装 `imsg`。
4. 创建 SSH 包装器，让 OpenClaw 能够在该用户上下文中运行 `imsg`。
5. 将 `channels.imessage.accounts.<id>.cliPath` 和 `.dbPath` 指向该用户配置文件。

首次运行可能需要在该机器人用户会话中授予 GUI 权限（自动化 + 完全磁盘访问权限）。

- Gateway 网关在 Linux/VM 上运行
- iMessage + `imsg` 在你的 tailnet 中的一台 Mac 上运行
- `cliPath` 包装器使用 SSH 运行 `imsg`
- `remoteHost` 启用 SCP 附件获取

示例：

```json5
{
  channels: {
    imessage: {
      enabled: true,
      cliPath: "~/.openclaw/scripts/imsg-ssh",
      remoteHost: "bot@mac-mini.tailnet-1234.ts.net",
      includeAttachments: true,
      dbPath: "/Users/bot/Library/Messages/chat.db",
    },
  },
}
```

```bash
#!/usr/bin/env bash
exec ssh -T bot@mac-mini.tailnet-1234.ts.net imsg "$@"
```

使用 SSH 密钥，让 SSH 和 SCP 都无需交互。
请先确保主机密钥受信任（例如 `ssh bot@mac-mini.tailnet-1234.ts.net`），以便填充 `known_hosts`。

每个账号都可以覆盖 `cliPath`、`dbPath`、`allowFrom`、`groupPolicy`、`mediaMaxMb`、历史记录设置以及附件根路径允许列表等字段。

- `chat_id:123`（推荐用于稳定路由）
- `chat_guid:...`
- `chat_identifier:...`

也支持句柄目标：

- `imessage:+1555...`
- `sms:+1555...`
- `user@example.com`

```bash
imsg chats --limit 20
```

{
  channels: {
    imessage: {
      actions: {
        reactions: true,
        edit: true,
        unsend: true,
        reply: true,
        sendWithEffect: true,
        sendAttachment: true,
        renameGroup: true,
        setGroupIcon: true,
        addParticipant: true,
        removeParticipant: true,
        leaveGroup: true,
      },
    },
  },
}

```json5
{
  channels: {
    imessage: {
      sendReadReceipts: false,
    },
  },
}
```

早于按方法能力列表的旧版 `imsg` 构建会静默关闭正在输入/已读门控；OpenClaw 会在每次重启时记录一次性警告，以便归因缺失的回执。

通知模式由 `channels.imessage.reactionNotifications` 控制：

- `"own"`（默认）：仅当用户对机器人撰写的消息作出反应时通知。
- `"all"`：通知来自已授权发送者的所有入站 tapback。
- `"off"`：忽略入站 tapback。

按账号覆盖使用 `channels.imessage.accounts.<id>.reactionNotifications`。

{
  channels: {
    imessage: {
      configWrites: false,
    },
  },
}

- 你发布的技能期望在一条消息中收到 `command + payload`（dump、paste、save、queue 等）。
- 你的用户会把 URL、图片或长内容与命令一起粘贴。
- 你可以接受增加的私信轮次延迟（见下文）。

在以下情况保持禁用：

- 你需要单词私信触发器具备最低命令延迟。
- 你的所有流程都是没有后续载荷的一次性命令。

开启该标志且没有显式设置 `messages.inbound.byChannel.imessage` 时，防抖窗口会扩大到 **2500 ms**（旧默认值为 0 ms，即不防抖）。需要更宽的窗口，是因为 Apple 的拆分发送节奏为 0.8-2.0 秒，无法适配更紧的默认值。

如需自行调整窗口：

```json5
{
  messages: {
    inbound: {
      byChannel: {
        // 2500 ms works for most setups; raise to 4000 ms if your Mac is
        // slow or under memory pressure (observed gap can stretch past 2 s
        // then).
        imessage: 2500,
      },
    },
  },
}
```

channels: {
  imessage: {
    catchup: {
      enabled: true,             // master switch (default: false)
      maxAgeMinutes: 120,        // skip rows older than now - 2h (default: 120, clamp 1..720)
      perRunLimit: 50,           // max rows replayed per startup (default: 50, clamp 1..500)
      firstRunLookbackMinutes: 30, // first run with no cursor: look back 30 min (default: 30)
      maxFailureRetries: 10,     // give up on a wedged guid after 10 dispatch failures (default: 10)
    },
  },
}

{
  "lastSeenMs": 1717900800000,
  "lastSeenRowid": 482910,
  "updatedAt": 1717900801234,
  "failureRetries": { "<guid>": 1 }
}

imessage catchup: replayed=N skippedFromMe=… skippedGivenUp=… failed=… givenUp=… fetchedCount=…
imessage catchup: giving up on guid=<guid> after <N> failures; advancing cursor past it
imessage catchup: fetched <X> rows across chats, capped to perRunLimit=<Y>

```bash
imsg rpc --help
imsg status --json
openclaw channels status --probe
```

如果探测报告 RPC 不受支持，请更新 `imsg`。如果私有 API 操作不可用，请在已登录的 macOS 用户会话中运行 `imsg launch`，然后再次探测。如果 Gateway 网关未在 macOS 上运行，请使用上面的通过 SSH 连接远程 Mac 设置，而不是默认的本地 `imsg` 路径。

#!/usr/bin/env bash
exec ssh -T messages-mac imsg "$@"

然后运行：

openclaw channels status --probe --channel imessage

- `channels.imessage.dmPolicy`
- `channels.imessage.allowFrom`
- 配对审批（`openclaw pairing list imessage`）

- `channels.imessage.groupPolicy`
- `channels.imessage.groupAllowFrom`
- `channels.imessage.groups` 允许列表行为
- 提及模式配置（`agents.list[].groupChat.mentionPatterns`）

- `channels.imessage.remoteHost`
- `channels.imessage.remoteAttachmentRoots`
- 来自 Gateway 网关主机的 SSH/SCP 密钥认证
- 主机密钥存在于 Gateway 网关主机上的 `~/.ssh/known_hosts`
- 运行 Messages 的 Mac 上远程路径可读

```bash
imsg chats --limit 1
imsg send <handle> "test"
```

确认运行 OpenClaw/`imsg` 的进程上下文已获得 Full Disk Access + Automation 权限。

openclaw plugins install @openclaw/line

openclaw plugins install ./path/to/local/line-plugin

https://gateway-host/line/webhook

{
  channels: {
    line: {
      enabled: true,
      channelAccessToken: "LINE_CHANNEL_ACCESS_TOKEN",
      channelSecret: "LINE_CHANNEL_SECRET",
      dmPolicy: "pairing",
    },
  },
}

{
  channels: {
    line: {
      enabled: true,
      channelAccessToken: "LINE_CHANNEL_ACCESS_TOKEN",
      channelSecret: "LINE_CHANNEL_SECRET",
      dmPolicy: "open",
      allowFrom: ["*"],
    },
  },
}

{
  channels: {
    line: {
      tokenFile: "/path/to/line-token.txt",
      secretFile: "/path/to/line-secret.txt",
    },
  },
}

{
  channels: {
    line: {
      accounts: {
        marketing: {
          channelAccessToken: "...",
          channelSecret: "...",
          webhookPath: "/line/marketing",
        },
      },
    },
  },
}

openclaw pairing list line
openclaw pairing approve line <CODE>

{
  text: "Here you go",
  channelData: {
    line: {
      quickReplies: ["Status", "Help"],
      location: {
        title: "Office",
        address: "123 Main St",
        latitude: 35.681236,
        longitude: 139.767125,
      },
      flexMessage: {
        altText: "Status card",
        contents: {
          /* Flex payload */
        },
      },
      templateMessage: {
        type: "confirm",
        text: "Proceed?",
        confirmLabel: "Yes",
        confirmData: "yes",
        cancelLabel: "No",
        cancelData: "no",
      },
    },
  },
}

/card info "Welcome" "Thanks for joining!"