@firstperson/firstperson 2026.1.33

package/src/channel.ts

@@ -0,0 +1,742 @@
+import {
+  buildChannelConfigSchema,
+  DEFAULT_ACCOUNT_ID,
+  formatPairingApproveHint,
+  PAIRING_APPROVED_MESSAGE,
+  setAccountEnabledInConfigSection,
+  deleteAccountFromConfigSection,
+  type ChannelPlugin,
+} from "openclaw/plugin-sdk";
+
+import { getFirstPersonRuntime } from "./runtime.js";
+import { FirstPersonConfigSchema } from "./config-schema.js";
+import type { FirstPersonConfig, ResolvedFirstPersonAccount, CoreConfig } from "./types.js";
+
+const DEFAULT_RELAY_URL = "wss://chat.firstperson.ai";
+
+const meta = {
+  id: "firstperson",
+  label: "First Person",
+  selectionLabel: "First Person (iOS)",
+  docsPath: "/channels/firstperson",
+  docsLabel: "firstperson",
+  blurb: "iOS app channel via WebSocket relay.",
+  order: 80,
+  quickstartAllowFrom: false,
+};
+
+function resolveFirstPersonAccount(params: {
+  cfg: CoreConfig;
+  accountId?: string | null;
+}): ResolvedFirstPersonAccount {
+  const { cfg, accountId } = params;
+  const fpConfig = (cfg.channels?.firstperson ?? {}) as FirstPersonConfig;
+  const token = fpConfig.token?.trim() || process.env.FIRSTPERSON_TOKEN?.trim() || null;
+
+  return {
+    accountId: accountId ?? DEFAULT_ACCOUNT_ID,
+    name: undefined,
+    enabled: fpConfig.enabled !== false,
+    configured: Boolean(token?.trim()),
+    token,
+    relayUrl: fpConfig.relayUrl?.trim() || DEFAULT_RELAY_URL,
+    config: fpConfig,
+    tokenSource: fpConfig.token ? "config" : process.env.FIRSTPERSON_TOKEN ? "env" : "none",
+  };
+}
+
+function listFirstPersonAccountIds(cfg: CoreConfig): string[] {
+  const fpConfig = cfg.channels?.firstperson;
+  if (!fpConfig) return [];
+  return [DEFAULT_ACCOUNT_ID];
+}
+
+export const firstPersonPlugin: ChannelPlugin<ResolvedFirstPersonAccount> = {
+  id: "firstperson",
+  meta,
+
+  capabilities: {
+    chatTypes: ["direct"],
+    reactions: false,
+    threads: false,
+    media: true,
+    polls: false,
+    nativeCommands: false,
+  },
+
+  reload: { configPrefixes: ["channels.firstperson"] },
+
+  configSchema: buildChannelConfigSchema(FirstPersonConfigSchema),
+
+  // ========== PAIRING (Native `openclaw pairing approve firstperson <code>`) ==========
+  pairing: {
+    idLabel: "deviceId",
+    normalizeAllowEntry: (entry) => entry.replace(/^firstperson:/i, "").trim().toLowerCase(),
+    notifyApproval: async ({ id }) => {
+      // Send approval notification to iOS app via relay
+      const runtime = getFirstPersonRuntime();
+      const cfg = await runtime.config.readConfigFile();
+      const account = resolveFirstPersonAccount({ cfg: cfg as CoreConfig });
+
+      if (!account.token) {
+        throw new Error("First Person token not configured - cannot send approval");
+      }
+
+      const { sendTextMessage } = await import("./relay-client.js");
+      await sendTextMessage({
+        relayUrl: account.relayUrl,
+        token: account.token,
+        to: id,
+        text: PAIRING_APPROVED_MESSAGE,
+      });
+    },
+  },
+
+  // ========== CONFIG ADAPTER ==========
+  config: {
+    listAccountIds: (cfg) => listFirstPersonAccountIds(cfg as CoreConfig),
+
+    resolveAccount: (cfg, accountId) =>
+      resolveFirstPersonAccount({ cfg: cfg as CoreConfig, accountId }),
+
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+
+    setAccountEnabled: ({ cfg, accountId, enabled }) =>
+      setAccountEnabledInConfigSection({
+        cfg: cfg as CoreConfig,
+        sectionKey: "firstperson",
+        accountId,
+        enabled,
+        allowTopLevel: true,
+      }),
+
+    deleteAccount: ({ cfg, accountId }) =>
+      deleteAccountFromConfigSection({
+        cfg: cfg as CoreConfig,
+        sectionKey: "firstperson",
+        accountId,
+        clearBaseFields: ["token", "relayUrl"],
+      }),
+
+    isConfigured: (account) => account.configured,
+
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      tokenSource: account.tokenSource,
+    }),
+
+    resolveAllowFrom: ({ cfg }) => {
+      const fpConfig = (cfg as CoreConfig).channels?.firstperson;
+      return (fpConfig?.allowFrom ?? []).map((entry) => String(entry));
+    },
+
+    formatAllowFrom: ({ allowFrom }) =>
+      allowFrom.map((entry) => String(entry).trim().toLowerCase()).filter(Boolean),
+  },
+
+  // ========== SECURITY ==========
+  security: {
+    resolveDmPolicy: ({ account }) => ({
+      policy: account.config.dmPolicy ?? "pairing",
+      allowFrom: account.config.allowFrom ?? [],
+      policyPath: "channels.firstperson.dmPolicy",
+      allowFromPath: "channels.firstperson.allowFrom",
+      approveHint: formatPairingApproveHint("firstperson"),
+      normalizeEntry: (raw) => raw.trim().replace(/^firstperson:/i, "").trim().toLowerCase(),
+    }),
+    collectWarnings: () => [],
+  },
+
+  // ========== SETUP ADAPTER ==========
+  setup: {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+
+    validateInput: ({ input }) => {
+      const typedInput = input as { token?: string; relayUrl?: string; useEnv?: boolean };
+      if (typedInput.useEnv) {
+        if (!process.env.FIRSTPERSON_TOKEN?.trim()) {
+          return "FIRSTPERSON_TOKEN environment variable not set.";
+        }
+        return null;
+      }
+      if (!typedInput.token?.trim()) {
+        return "First Person requires a relay token. Set FIRSTPERSON_TOKEN or provide --token.";
+      }
+      return null;
+    },
+
+    applyAccountConfig: ({ cfg, input }) => {
+      const typedInput = input as { token?: string; relayUrl?: string; useEnv?: boolean };
+      const coreCfg = cfg as CoreConfig;
+      const fpConfig = coreCfg.channels?.firstperson ?? {};
+
+      return {
+        ...coreCfg,
+        channels: {
+          ...coreCfg.channels,
+          firstperson: {
+            ...fpConfig,
+            enabled: true,
+            // Only write token to config if not using env var
+            ...(typedInput.useEnv ? {} : typedInput.token ? { token: typedInput.token } : {}),
+            ...(typedInput.relayUrl ? { relayUrl: typedInput.relayUrl } : {}),
+          },
+        },
+      };
+    },
+  },
+
+  // ========== OUTBOUND ==========
+  outbound: {
+    deliveryMode: "direct",
+    textChunkLimit: 4096,
+
+    sendText: async ({ to, text, cfg }) => {
+      const account = resolveFirstPersonAccount({ cfg: cfg as CoreConfig });
+      if (!account.token) {
+        throw new Error("First Person not configured - no token");
+      }
+
+      const { sendTextMessage } = await import("./relay-client.js");
+      const result = await sendTextMessage({
+        relayUrl: account.relayUrl,
+        token: account.token,
+        to,
+        text,
+      });
+
+      return { channel: "firstperson", messageId: result.messageId, chatId: result.chatId };
+    },
+
+    sendPayload: async ({ to, payload, cfg }) => {
+      const account = resolveFirstPersonAccount({ cfg: cfg as CoreConfig });
+      if (!account.token) {
+        throw new Error("First Person not configured - no token");
+      }
+
+      const { sendTextMessage } = await import("./relay-client.js");
+      const result = await sendTextMessage({
+        relayUrl: account.relayUrl,
+        token: account.token,
+        to,
+        text: payload.text ?? "",
+      });
+
+      return { channel: "firstperson", messageId: result.messageId, chatId: result.chatId };
+    },
+  },
+
+  // ========== STATUS ==========
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+    },
+
+    collectStatusIssues: (accounts) =>
+      accounts.flatMap((account) => {
+        const issues: Array<{ channel: string; accountId: string; kind: string; message: string }> = [];
+        if (!account.configured) {
+          issues.push({
+            channel: "firstperson",
+            accountId: account.accountId,
+            kind: "config",
+            message: "First Person token not configured",
+          });
+        }
+        return issues;
+      }),
+
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      lastStartAt: snapshot.lastStartAt ?? null,
+      lastStopAt: snapshot.lastStopAt ?? null,
+      lastError: snapshot.lastError ?? null,
+    }),
+
+    buildAccountSnapshot: ({ account, runtime }) => ({
+      accountId: account.accountId,
+      name: account.name,
+      enabled: account.enabled,
+      configured: account.configured,
+      tokenSource: account.tokenSource,
+      relayUrl: account.relayUrl,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+    }),
+  },
+
+  // ========== GATEWAY ==========
+  gateway: {
+    startAccount: async (ctx) => {
+      const { account, abortSignal, log, setStatus, runtime, cfg } = ctx;
+
+      if (!account.token) {
+        throw new Error("First Person token not configured");
+      }
+
+      log?.info(`[firstperson:${account.accountId}] starting relay connection to ${account.relayUrl}`);
+
+      setStatus({
+        accountId: account.accountId,
+        running: false,
+        lastStartAt: null,
+        lastStopAt: null,
+        lastError: null,
+      });
+
+      const { startRelayConnection } = await import("./relay-client.js");
+
+      return startRelayConnection({
+        relayUrl: account.relayUrl,
+        token: account.token,
+        accountId: account.accountId,
+        abortSignal,
+        log,
+        onConnected: () => {
+          setStatus({
+            accountId: account.accountId,
+            running: true,
+            lastStartAt: new Date().toISOString(),
+            lastStopAt: null,
+            lastError: null,
+          });
+          log?.info(`[firstperson:${account.accountId}] relay connected`);
+        },
+        onDisconnected: (error) => {
+          setStatus({
+            accountId: account.accountId,
+            running: false,
+            lastStartAt: null,
+            lastStopAt: new Date().toISOString(),
+            lastError: error?.message ?? null,
+          });
+          log?.warn(`[firstperson:${account.accountId}] relay disconnected: ${error?.message ?? "unknown"}`);
+        },
+        onMessage: async (message) => {
+          log?.info(`[fp] 1. received: ${message.messageId} from ${message.deviceId}`);
+
+          try {
+            const globalRuntime = getFirstPersonRuntime();
+            const channelApi = (globalRuntime as any).channel;
+
+            if (!channelApi?.pairing) {
+              log?.error(`[fp] ERROR: runtime.channel.pairing not available`);
+              return;
+            }
+
+            // ========== SECURITY CHECK ==========
+            const fpConfig = (cfg as CoreConfig).channels?.firstperson ?? {};
+            const dmPolicy = fpConfig.dmPolicy ?? "pairing";
+            log?.info(`[fp] 2. checking authorization (dmPolicy=${dmPolicy})`);
+
+            // Get effective allowFrom (config + pairing store)
+            const configAllowFrom = (fpConfig.allowFrom ?? [])
+              .map((v: string | number) => String(v).trim().toLowerCase())
+              .filter(Boolean);
+            const hasWildcard = configAllowFrom.includes("*");
+            const filteredConfig = configAllowFrom.filter((v: string) => v !== "*");
+
+            // Read from pairing store
+            const storeAllowFrom = await channelApi.pairing.readAllowFromStore("firstperson");
+            const effectiveEntries = Array.from(new Set([...filteredConfig, ...storeAllowFrom]));
+
+            // Check if device is allowed
+            const normalizedDeviceId = message.deviceId.trim().toLowerCase();
+            const deviceAllowed = hasWildcard || effectiveEntries.some(
+              (entry: string) => entry.toLowerCase() === normalizedDeviceId
+            );
+
+            log?.info(`[fp] 3. device ${message.deviceId} allowed=${deviceAllowed} (hasWildcard=${hasWildcard}, entries=${effectiveEntries.length})`);
+
+            if (!deviceAllowed) {
+              if (dmPolicy === "pairing") {
+                // Generate pairing code and send to device
+                log?.info(`[fp] 4. generating pairing code for ${message.deviceId}`);
+                const { code, created } = await channelApi.pairing.upsertPairingRequest({
+                  channel: "firstperson",
+                  id: message.deviceId,
+                });
+
+                if (created && code) {
+                  log?.info(`[fp] 5. sending pairing code ${code} to device`);
+                  const { sendTextMessage } = await import("./relay-client.js");
+                  await sendTextMessage({
+                    relayUrl: account.relayUrl,
+                    token: account.token!,
+                    to: message.deviceId,
+                    text: [
+                      "OpenClaw: access not configured.",
+                      "",
+                      `Your device id: ${message.deviceId}`,
+                      "",
+                      `Pairing code: ${code}`,
+                      "",
+                      "Ask the bot owner to approve with:",
+                      `  openclaw pairing approve firstperson ${code}`,
+                    ].join("\n"),
+                  });
+                  log?.info(`[fp] 6. pairing code sent`);
+                } else {
+                  log?.info(`[fp] 5. pairing request already exists (code=${code}, created=${created})`);
+                }
+                return; // Don't dispatch - waiting for pairing approval
+              } else if (dmPolicy === "disabled") {
+                log?.info(`[fp] 4. blocking message from unauthorized device (dmPolicy=disabled)`);
+                return;
+              }
+              // dmPolicy === "open" with no wildcard should not reach here
+              // since we already checked hasWildcard
+              log?.warn(`[fp] 4. unexpected state: device not allowed but dmPolicy=${dmPolicy}`);
+              return;
+            }
+
+            log?.info(`[fp] 4. device authorized, proceeding with dispatch`);
+
+            // ========== ROUTING & DISPATCH ==========
+            log?.info(`[fp] 5. runtime available: ${!!channelApi?.routing}`);
+
+            // Use channel.routing API if available
+            if (channelApi?.routing) {
+              // Resolve routing
+              const route = channelApi.routing.resolveAgentRoute({
+                cfg,
+                channel: "firstperson",
+                peer: { kind: "dm", id: message.deviceId },
+              });
+              log?.info(`[fp] 6. route resolved: ${route ? route.sessionKey : "NULL"}`);
+
+              if (!route) {
+                log?.warn(`[fp] no route - check bindings for ${message.deviceId}`);
+                return;
+              }
+
+              // Session setup
+              log?.info(`[fp] 7. setting up session...`);
+              const storePath = channelApi.session.resolveStorePath((cfg as any).session?.store, {
+                agentId: route.agentId,
+              });
+
+              let previousTimestamp = null;
+              try {
+                previousTimestamp = channelApi.session.readSessionUpdatedAt({
+                  storePath,
+                  sessionKey: route.sessionKey,
+                });
+              } catch {
+                // No previous session, that's fine
+              }
+
+              // Format message envelope
+              const envelopeOptions = channelApi.reply.resolveEnvelopeFormatOptions(cfg);
+              const body = channelApi.reply.formatAgentEnvelope({
+                channel: "First Person",
+                from: message.deviceId,
+                timestamp: message.timestamp ?? new Date().toISOString(),
+                previousTimestamp,
+                envelope: envelopeOptions,
+                body: message.text,
+              });
+
+              // Build inbound context
+              const ctxPayload = channelApi.reply.finalizeInboundContext({
+                Body: body,
+                RawBody: message.text,
+                CommandBody: message.text,
+                From: `firstperson:${message.deviceId}`,
+                To: `device:${message.deviceId}`,
+                SessionKey: route.sessionKey,
+                AccountId: route.accountId,
+                ChatType: "direct",
+                ConversationLabel: message.deviceId,
+                SenderName: message.deviceId,
+                SenderId: message.deviceId,
+                Provider: "firstperson",
+                Surface: "firstperson",
+                MessageSid: message.messageId,
+                Timestamp: message.timestamp ?? new Date().toISOString(),
+                CommandAuthorized: true,
+                OriginatingChannel: "firstperson",
+                OriginatingTo: `device:${message.deviceId}`,
+              });
+
+              // Record session
+              await channelApi.session.recordInboundSession({
+                storePath,
+                sessionKey: route.sessionKey,
+                ctx: ctxPayload,
+              });
+              log?.info(`[fp] 8. session recorded, starting dispatch...`);
+
+              // Create dispatcher for replies
+              const { sendTextMessage } = await import("./relay-client.js");
+              const { dispatcher, replyOptions } = channelApi.reply.createReplyDispatcherWithTyping({
+                deliver: async (payload: { text?: string }) => {
+                  log?.info(`[fp] 9. delivering reply: ${(payload.text ?? "").substring(0, 50)}...`);
+                  await sendTextMessage({
+                    relayUrl: account.relayUrl,
+                    token: account.token!,
+                    to: message.deviceId,
+                    text: payload.text ?? "",
+                    replyTo: message.messageId,
+                  });
+                  log?.info(`[fp] 10. reply sent`);
+                },
+                onError: (err: Error) => {
+                  log?.error(`[fp] reply delivery failed: ${err.message}`);
+                },
+              });
+
+              // Dispatch to agent
+              await channelApi.reply.dispatchReplyFromConfig({
+                ctx: ctxPayload,
+                cfg,
+                dispatcher,
+                replyOptions,
+              });
+              log?.info(`[fp] 11. dispatch complete`);
+              return;
+            }
+
+            // Fallback: agent.enqueueInbound
+            if ((globalRuntime as any).agent?.enqueueInbound) {
+              log?.info(`[fp] fallback: using agent.enqueueInbound`);
+              const { sendTextMessage } = await import("./relay-client.js");
+              await (globalRuntime as any).agent.enqueueInbound({
+                channel: "firstperson",
+                accountId: account.accountId,
+                chatType: "direct",
+                from: `firstperson:${message.deviceId}`,
+                to: `device:${message.deviceId}`,
+                body: message.text,
+                rawBody: message.text,
+                messageId: message.messageId,
+                timestamp: message.timestamp ?? new Date().toISOString(),
+                senderId: message.deviceId,
+                senderName: message.deviceId,
+                reply: async (text: string) => {
+                  log?.info(`[fp] fallback reply sent`);
+                  await sendTextMessage({
+                    relayUrl: account.relayUrl,
+                    token: account.token!,
+                    to: message.deviceId,
+                    text,
+                    replyTo: message.messageId,
+                  });
+                },
+              });
+              return;
+            }
+
+            // Fallback: gateway.handleInbound
+            if ((globalRuntime as any).gateway?.handleInbound) {
+              log?.info(`[fp] fallback: using gateway.handleInbound`);
+              const { sendTextMessage } = await import("./relay-client.js");
+              await (globalRuntime as any).gateway.handleInbound({
+                channel: "firstperson",
+                accountId: account.accountId,
+                from: message.deviceId,
+                body: message.text,
+                chatType: "direct",
+                messageId: message.messageId,
+                reply: async (text: string) => {
+                  log?.info(`[fp] fallback reply sent`);
+                  await sendTextMessage({
+                    relayUrl: account.relayUrl,
+                    token: account.token!,
+                    to: message.deviceId,
+                    text,
+                    replyTo: message.messageId,
+                  });
+                },
+              });
+              return;
+            }
+
+            log?.error(`[fp] ERROR: no dispatch method available on runtime`);
+
+          } catch (err) {
+            log?.error(`[fp] ERROR processing message: ${err}`);
+          }
+        },
+      });
+    },
+
+    logoutAccount: async ({ cfg }) => {
+      const coreCfg = cfg as CoreConfig;
+      const fpConfig = coreCfg.channels?.firstperson ?? {};
+      const hadToken = Boolean(fpConfig.token);
+
+      if (hadToken) {
+        const { token, ...rest } = fpConfig;
+        const runtime = getFirstPersonRuntime();
+        await runtime.config.writeConfigFile({
+          ...coreCfg,
+          channels: {
+            ...coreCfg.channels,
+            firstperson: rest,
+          },
+        });
+      }
+
+      return { cleared: hadToken, loggedOut: true };
+    },
+  },
+
+  // ========== MESSAGING ==========
+  messaging: {
+    normalizeTarget: (target) => {
+      const trimmed = target?.trim().toLowerCase();
+      return trimmed || undefined;
+    },
+    targetResolver: {
+      looksLikeId: (id) => Boolean(id?.trim()),
+      hint: "<deviceId>",
+    },
+  },
+
+  // ========== DIRECTORY ==========
+  directory: {
+    self: async () => null,
+    listPeers: async ({ cfg }) => {
+      const fpConfig = (cfg as CoreConfig).channels?.firstperson;
+      const allowFrom = fpConfig?.allowFrom ?? [];
+      return allowFrom
+        .map((entry) => String(entry).trim())
+        .filter(Boolean)
+        .map((id) => ({ kind: "user" as const, id }));
+    },
+    listGroups: async () => [],
+  },
+
+  // ========== ONBOARDING (openclaw channels add --channel firstperson) ==========
+  onboarding: {
+    channel: "firstperson",
+
+    getStatus: async ({ cfg }) => {
+      const account = resolveFirstPersonAccount({ cfg: cfg as CoreConfig });
+      return {
+        channel: "firstperson",
+        configured: account.configured,
+        statusLines: [`First Person: ${account.configured ? "configured" : "needs token"}`],
+        selectionHint: account.configured ? "configured" : "iOS app channel",
+        quickstartScore: account.configured ? 1 : 5,
+      };
+    },
+
+    configure: async ({ cfg, prompter }) => {
+      let next = cfg as CoreConfig;
+      const existing = resolveFirstPersonAccount({ cfg: next });
+      const hasExistingToken = Boolean(existing.token);
+      const canUseEnv = Boolean(process.env.FIRSTPERSON_TOKEN?.trim());
+
+      // Show setup instructions
+      await prompter.note(
+        [
+          "1) Open the First Person iOS app",
+          "2) Go to Settings → OpenClaw Connection",
+          "3) Copy your relay token",
+          "",
+          "Tip: You can also set FIRSTPERSON_TOKEN in your env.",
+        ].join("\n"),
+        "First Person relay token",
+      );
+
+      let token: string | null = null;
+
+      // Check for env token
+      if (canUseEnv && !existing.config.token) {
+        const keepEnv = await prompter.confirm({
+          message: "FIRSTPERSON_TOKEN detected. Use env var?",
+          initialValue: true,
+        });
+        if (!keepEnv) {
+          token = String(
+            await prompter.text({
+              message: "Enter First Person relay token",
+              validate: (value) => (value?.trim() ? undefined : "Required"),
+            }),
+          ).trim();
+        }
+      } else if (hasExistingToken) {
+        const keep = await prompter.confirm({
+          message: "First Person token already configured. Keep it?",
+          initialValue: true,
+        });
+        if (!keep) {
+          token = String(
+            await prompter.text({
+              message: "Enter First Person relay token",
+              validate: (value) => (value?.trim() ? undefined : "Required"),
+            }),
+          ).trim();
+        }
+      } else {
+        token = String(
+          await prompter.text({
+            message: "Enter First Person relay token",
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+          }),
+        ).trim();
+      }
+
+      // Apply config
+      next = {
+        ...next,
+        channels: {
+          ...next.channels,
+          firstperson: {
+            ...next.channels?.firstperson,
+            enabled: true,
+            dmPolicy: "pairing",
+            ...(token ? { token } : {}),
+          },
+        },
+      };
+
+      return { cfg: next, accountId: DEFAULT_ACCOUNT_ID };
+    },
+
+    dmPolicy: {
+      label: "First Person",
+      channel: "firstperson",
+      policyKey: "channels.firstperson.dmPolicy",
+      allowFromKey: "channels.firstperson.allowFrom",
+      getCurrent: (cfg) => (cfg as CoreConfig).channels?.firstperson?.dmPolicy ?? "pairing",
+      setPolicy: (cfg, policy) => {
+        const coreCfg = cfg as CoreConfig;
+        const allowFrom = policy === "open"
+          ? [...(coreCfg.channels?.firstperson?.allowFrom ?? []), "*"].filter((v, i, a) => a.indexOf(v) === i)
+          : coreCfg.channels?.firstperson?.allowFrom;
+        return {
+          ...coreCfg,
+          channels: {
+            ...coreCfg.channels,
+            firstperson: {
+              ...coreCfg.channels?.firstperson,
+              dmPolicy: policy,
+              ...(allowFrom ? { allowFrom } : {}),
+            },
+          },
+        };
+      },
+    },
+
+    disable: (cfg) => ({
+      ...cfg,
+      channels: {
+        ...(cfg as CoreConfig).channels,
+        firstperson: { ...(cfg as CoreConfig).channels?.firstperson, enabled: false },
+      },
+    }),
+  },
+};