@firstperson/firstperson 2026.1.33

package/src/channel.test.ts

@@ -0,0 +1,650 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from "vitest";
+import type { CoreConfig } from "./types.js";
+
+// Mock openclaw/plugin-sdk
+vi.mock("openclaw/plugin-sdk", () => ({
+  buildChannelConfigSchema: vi.fn((schema) => schema),
+  DEFAULT_ACCOUNT_ID: "default",
+  formatPairingApproveHint: vi.fn((channel) => `openclaw pairing approve ${channel} <code>`),
+  PAIRING_APPROVED_MESSAGE: "Your device has been approved.",
+  setAccountEnabledInConfigSection: vi.fn(({ cfg, sectionKey, enabled }) => ({
+    ...cfg,
+    channels: {
+      ...cfg.channels,
+      [sectionKey]: { ...cfg.channels?.[sectionKey], enabled },
+    },
+  })),
+  deleteAccountFromConfigSection: vi.fn(({ cfg, sectionKey }) => {
+    const { [sectionKey]: _, ...rest } = cfg.channels || {};
+    return { ...cfg, channels: rest };
+  }),
+}));
+
+// Mock the runtime module
+vi.mock("./runtime.js", () => ({
+  getFirstPersonRuntime: vi.fn(() => ({
+    config: {
+      readConfigFile: vi.fn().mockResolvedValue({}),
+      writeConfigFile: vi.fn().mockResolvedValue(undefined),
+    },
+  })),
+}));
+
+// Import after mocks are set up
+const { firstPersonPlugin } = await import("./channel.js");
+
+describe("firstPersonPlugin", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    vi.resetModules();
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("meta", () => {
+    it("has correct channel metadata", () => {
+      expect(firstPersonPlugin.id).toBe("firstperson");
+      expect(firstPersonPlugin.meta.label).toBe("First Person");
+      expect(firstPersonPlugin.meta.selectionLabel).toBe("First Person (iOS)");
+      expect(firstPersonPlugin.meta.docsPath).toBe("/channels/firstperson");
+    });
+  });
+
+  describe("capabilities", () => {
+    it("supports direct messages only", () => {
+      expect(firstPersonPlugin.capabilities.chatTypes).toEqual(["direct"]);
+    });
+
+    it("supports media", () => {
+      expect(firstPersonPlugin.capabilities.media).toBe(true);
+    });
+
+    it("does not support threads or reactions", () => {
+      expect(firstPersonPlugin.capabilities.threads).toBe(false);
+      expect(firstPersonPlugin.capabilities.reactions).toBe(false);
+    });
+  });
+
+  describe("config adapter", () => {
+    describe("listAccountIds", () => {
+      it("returns empty array when no config", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.config.listAccountIds(cfg);
+        expect(result).toEqual([]);
+      });
+
+      it("returns default account when configured", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              token: "fp_token_123",
+            },
+          },
+        };
+        const result = firstPersonPlugin.config.listAccountIds(cfg);
+        expect(result).toEqual(["default"]);
+      });
+    });
+
+    describe("resolveAccount", () => {
+      it("resolves account from config token", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              token: "fp_token_123",
+              relayUrl: "wss://custom.relay.ai",
+            },
+          },
+        };
+
+        const account = firstPersonPlugin.config.resolveAccount(cfg, "default");
+
+        expect(account.accountId).toBe("default");
+        expect(account.token).toBe("fp_token_123");
+        expect(account.relayUrl).toBe("wss://custom.relay.ai");
+        expect(account.tokenSource).toBe("config");
+        expect(account.configured).toBe(true);
+        expect(account.enabled).toBe(true);
+      });
+
+      it("falls back to env token when no config token", () => {
+        process.env.FIRSTPERSON_TOKEN = "fp_env_token";
+
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {},
+          },
+        };
+
+        const account = firstPersonPlugin.config.resolveAccount(cfg, "default");
+
+        expect(account.token).toBe("fp_env_token");
+        expect(account.tokenSource).toBe("env");
+        expect(account.configured).toBe(true);
+      });
+
+      it("uses default relay URL when not specified", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              token: "fp_token_123",
+            },
+          },
+        };
+
+        const account = firstPersonPlugin.config.resolveAccount(cfg, "default");
+
+        expect(account.relayUrl).toBe("wss://chat.firstperson.ai");
+      });
+
+      it("respects enabled flag", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              enabled: false,
+              token: "fp_token_123",
+            },
+          },
+        };
+
+        const account = firstPersonPlugin.config.resolveAccount(cfg, "default");
+
+        expect(account.enabled).toBe(false);
+      });
+
+      it("returns unconfigured when no token", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {},
+          },
+        };
+
+        const account = firstPersonPlugin.config.resolveAccount(cfg, "default");
+
+        expect(account.token).toBeNull();
+        expect(account.tokenSource).toBe("none");
+        expect(account.configured).toBe(false);
+      });
+    });
+
+    describe("isConfigured", () => {
+      it("returns true when account has token", () => {
+        const account = {
+          accountId: "default",
+          configured: true,
+          token: "fp_token_123",
+          tokenSource: "config" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {},
+        };
+
+        expect(firstPersonPlugin.config.isConfigured(account)).toBe(true);
+      });
+
+      it("returns false when account has no token", () => {
+        const account = {
+          accountId: "default",
+          configured: false,
+          token: null,
+          tokenSource: "none" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {},
+        };
+
+        expect(firstPersonPlugin.config.isConfigured(account)).toBe(false);
+      });
+    });
+
+    describe("resolveAllowFrom", () => {
+      it("returns allowFrom array from config", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              allowFrom: ["device-1", "device-2"],
+            },
+          },
+        };
+
+        const result = firstPersonPlugin.config.resolveAllowFrom!({ cfg });
+        expect(result).toEqual(["device-1", "device-2"]);
+      });
+
+      it("returns empty array when no allowFrom", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {},
+          },
+        };
+
+        const result = firstPersonPlugin.config.resolveAllowFrom!({ cfg });
+        expect(result).toEqual([]);
+      });
+
+      it("converts numbers to strings", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              allowFrom: [123, "device-1"],
+            },
+          },
+        };
+
+        const result = firstPersonPlugin.config.resolveAllowFrom!({ cfg });
+        expect(result).toEqual(["123", "device-1"]);
+      });
+    });
+
+    describe("formatAllowFrom", () => {
+      it("normalizes and filters entries", () => {
+        const result = firstPersonPlugin.config.formatAllowFrom!({
+          allowFrom: ["  Device-1  ", "DEVICE-2", "", "  "],
+        });
+
+        expect(result).toEqual(["device-1", "device-2"]);
+      });
+    });
+  });
+
+  describe("security adapter", () => {
+    describe("resolveDmPolicy", () => {
+      it("defaults to pairing policy", () => {
+        const account = {
+          accountId: "default",
+          configured: true,
+          token: "fp_token_123",
+          tokenSource: "config" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {},
+        };
+
+        const result = firstPersonPlugin.security!.resolveDmPolicy({ account });
+
+        expect(result.policy).toBe("pairing");
+      });
+
+      it("uses configured policy", () => {
+        const account = {
+          accountId: "default",
+          configured: true,
+          token: "fp_token_123",
+          tokenSource: "config" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {
+            dmPolicy: "allowlist" as const,
+          },
+        };
+
+        const result = firstPersonPlugin.security!.resolveDmPolicy({ account });
+
+        expect(result.policy).toBe("allowlist");
+      });
+
+      it("includes allowFrom from config", () => {
+        const account = {
+          accountId: "default",
+          configured: true,
+          token: "fp_token_123",
+          tokenSource: "config" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {
+            allowFrom: ["device-1", "device-2"],
+          },
+        };
+
+        const result = firstPersonPlugin.security!.resolveDmPolicy({ account });
+
+        expect(result.allowFrom).toEqual(["device-1", "device-2"]);
+      });
+
+      it("normalizes entries correctly", () => {
+        const account = {
+          accountId: "default",
+          configured: true,
+          token: "fp_token_123",
+          tokenSource: "config" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {},
+        };
+
+        const result = firstPersonPlugin.security!.resolveDmPolicy({ account });
+
+        expect(result.normalizeEntry("  firstperson:Device-1  ")).toBe("device-1");
+        expect(result.normalizeEntry("FIRSTPERSON:DEVICE-2")).toBe("device-2");
+      });
+    });
+  });
+
+  describe("pairing adapter", () => {
+    it("normalizes allow entries", () => {
+      const normalized = firstPersonPlugin.pairing!.normalizeAllowEntry("firstperson:Device-123");
+      expect(normalized).toBe("device-123");
+    });
+
+    it("handles entries without prefix", () => {
+      const normalized = firstPersonPlugin.pairing!.normalizeAllowEntry("  DEVICE-456  ");
+      expect(normalized).toBe("device-456");
+    });
+  });
+
+  describe("messaging adapter", () => {
+    describe("normalizeTarget", () => {
+      it("normalizes target to lowercase", () => {
+        const result = firstPersonPlugin.messaging!.normalizeTarget("DEVICE-123");
+        expect(result).toBe("device-123");
+      });
+
+      it("trims whitespace", () => {
+        const result = firstPersonPlugin.messaging!.normalizeTarget("  device-123  ");
+        expect(result).toBe("device-123");
+      });
+
+      it("returns undefined for empty input", () => {
+        const result = firstPersonPlugin.messaging!.normalizeTarget("");
+        expect(result).toBeUndefined();
+      });
+
+      it("returns undefined for undefined input", () => {
+        const result = firstPersonPlugin.messaging!.normalizeTarget(undefined as unknown as string);
+        expect(result).toBeUndefined();
+      });
+    });
+
+    describe("targetResolver", () => {
+      it("identifies valid device IDs", () => {
+        expect(firstPersonPlugin.messaging!.targetResolver!.looksLikeId("device-123")).toBe(true);
+        expect(firstPersonPlugin.messaging!.targetResolver!.looksLikeId("abc")).toBe(true);
+      });
+
+      it("rejects empty IDs", () => {
+        expect(firstPersonPlugin.messaging!.targetResolver!.looksLikeId("")).toBe(false);
+        expect(firstPersonPlugin.messaging!.targetResolver!.looksLikeId("   ")).toBe(false);
+      });
+
+      it("provides correct hint", () => {
+        expect(firstPersonPlugin.messaging!.targetResolver!.hint).toBe("<deviceId>");
+      });
+    });
+  });
+
+  describe("directory adapter", () => {
+    it("lists peers from allowFrom", async () => {
+      const cfg: CoreConfig = {
+        channels: {
+          firstperson: {
+            allowFrom: ["device-1", "device-2"],
+          },
+        },
+      };
+
+      const peers = await firstPersonPlugin.directory!.listPeers!({ cfg });
+
+      expect(peers).toEqual([
+        { kind: "user", id: "device-1" },
+        { kind: "user", id: "device-2" },
+      ]);
+    });
+
+    it("returns empty array when no allowFrom", async () => {
+      const cfg: CoreConfig = {
+        channels: {
+          firstperson: {},
+        },
+      };
+
+      const peers = await firstPersonPlugin.directory!.listPeers!({ cfg });
+      expect(peers).toEqual([]);
+    });
+
+    it("filters empty entries", async () => {
+      const cfg: CoreConfig = {
+        channels: {
+          firstperson: {
+            allowFrom: ["device-1", "", "  ", "device-2"],
+          },
+        },
+      };
+
+      const peers = await firstPersonPlugin.directory!.listPeers!({ cfg });
+
+      expect(peers).toEqual([
+        { kind: "user", id: "device-1" },
+        { kind: "user", id: "device-2" },
+      ]);
+    });
+
+    it("returns empty groups array", async () => {
+      const groups = await firstPersonPlugin.directory!.listGroups!({ cfg: {} });
+      expect(groups).toEqual([]);
+    });
+
+    it("returns null for self", async () => {
+      const self = await firstPersonPlugin.directory!.self!({ cfg: {} });
+      expect(self).toBeNull();
+    });
+  });
+
+  describe("setup adapter", () => {
+    describe("validateInput", () => {
+      it("accepts valid token", () => {
+        const result = firstPersonPlugin.setup!.validateInput!({
+          input: { token: "fp_token_123" },
+        } as any);
+        expect(result).toBeNull();
+      });
+
+      it("rejects empty token when not using env", () => {
+        const result = firstPersonPlugin.setup!.validateInput!({
+          input: { token: "" },
+        } as any);
+        expect(result).toContain("requires a relay token");
+      });
+
+      it("accepts useEnv when env var is set", () => {
+        process.env.FIRSTPERSON_TOKEN = "fp_env_token";
+
+        const result = firstPersonPlugin.setup!.validateInput!({
+          input: { useEnv: true },
+        } as any);
+        expect(result).toBeNull();
+      });
+
+      it("rejects useEnv when env var is not set", () => {
+        delete process.env.FIRSTPERSON_TOKEN;
+
+        const result = firstPersonPlugin.setup!.validateInput!({
+          input: { useEnv: true },
+        } as any);
+        expect(result).toContain("FIRSTPERSON_TOKEN environment variable not set");
+      });
+    });
+
+    describe("applyAccountConfig", () => {
+      it("applies token to config", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.setup!.applyAccountConfig!({
+          cfg,
+          input: { token: "fp_token_123" },
+        } as any);
+
+        expect(result.channels?.firstperson?.token).toBe("fp_token_123");
+        expect(result.channels?.firstperson?.enabled).toBe(true);
+      });
+
+      it("applies relayUrl to config", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.setup!.applyAccountConfig!({
+          cfg,
+          input: { token: "fp_token_123", relayUrl: "wss://custom.relay.ai" },
+        } as any);
+
+        expect(result.channels?.firstperson?.relayUrl).toBe("wss://custom.relay.ai");
+      });
+
+      it("does not write token when using env", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.setup!.applyAccountConfig!({
+          cfg,
+          input: { useEnv: true },
+        } as any);
+
+        expect(result.channels?.firstperson?.token).toBeUndefined();
+        expect(result.channels?.firstperson?.enabled).toBe(true);
+      });
+
+      it("preserves existing config", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              dmPolicy: "allowlist",
+              allowFrom: ["existing-device"],
+            },
+          },
+        };
+
+        const result = firstPersonPlugin.setup!.applyAccountConfig!({
+          cfg,
+          input: { token: "fp_token_123" },
+        } as any);
+
+        expect(result.channels?.firstperson?.dmPolicy).toBe("allowlist");
+        expect(result.channels?.firstperson?.allowFrom).toEqual(["existing-device"]);
+        expect(result.channels?.firstperson?.token).toBe("fp_token_123");
+      });
+    });
+  });
+
+  describe("status adapter", () => {
+    it("collects config issues when not configured", () => {
+      const accounts = [
+        {
+          accountId: "default",
+          configured: false,
+          token: null,
+          tokenSource: "none" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {},
+        },
+      ];
+
+      const issues = firstPersonPlugin.status!.collectStatusIssues!(accounts);
+
+      expect(issues).toHaveLength(1);
+      expect(issues[0]).toEqual({
+        channel: "firstperson",
+        accountId: "default",
+        kind: "config",
+        message: "First Person token not configured",
+      });
+    });
+
+    it("returns no issues when configured", () => {
+      const accounts = [
+        {
+          accountId: "default",
+          configured: true,
+          token: "fp_token_123",
+          tokenSource: "config" as const,
+          enabled: true,
+          relayUrl: "wss://chat.firstperson.ai",
+          config: {},
+        },
+      ];
+
+      const issues = firstPersonPlugin.status!.collectStatusIssues!(accounts);
+      expect(issues).toHaveLength(0);
+    });
+  });
+
+  describe("outbound adapter", () => {
+    it("has correct delivery mode", () => {
+      expect(firstPersonPlugin.outbound!.deliveryMode).toBe("direct");
+    });
+
+    it("has correct text chunk limit", () => {
+      expect(firstPersonPlugin.outbound!.textChunkLimit).toBe(4096);
+    });
+  });
+
+  describe("onboarding adapter", () => {
+    describe("dmPolicy", () => {
+      it("gets current policy defaulting to pairing", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.onboarding!.dmPolicy!.getCurrent(cfg);
+        expect(result).toBe("pairing");
+      });
+
+      it("gets configured policy", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              dmPolicy: "allowlist",
+            },
+          },
+        };
+        const result = firstPersonPlugin.onboarding!.dmPolicy!.getCurrent(cfg);
+        expect(result).toBe("allowlist");
+      });
+
+      it("sets policy and adds wildcard for open", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.onboarding!.dmPolicy!.setPolicy(cfg, "open");
+
+        expect(result.channels?.firstperson?.dmPolicy).toBe("open");
+        expect(result.channels?.firstperson?.allowFrom).toContain("*");
+      });
+
+      it("sets policy without wildcard for non-open", () => {
+        const cfg: CoreConfig = {};
+        const result = firstPersonPlugin.onboarding!.dmPolicy!.setPolicy(cfg, "pairing");
+
+        expect(result.channels?.firstperson?.dmPolicy).toBe("pairing");
+        expect(result.channels?.firstperson?.allowFrom).toBeUndefined();
+      });
+
+      it("deduplicates wildcard when already present", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              allowFrom: ["*", "device-1"],
+            },
+          },
+        };
+        const result = firstPersonPlugin.onboarding!.dmPolicy!.setPolicy(cfg, "open");
+
+        const wildcardCount = result.channels?.firstperson?.allowFrom?.filter(
+          (v: string | number) => v === "*"
+        ).length;
+        expect(wildcardCount).toBe(1);
+      });
+    });
+
+    describe("disable", () => {
+      it("sets enabled to false", () => {
+        const cfg: CoreConfig = {
+          channels: {
+            firstperson: {
+              enabled: true,
+              token: "fp_token_123",
+            },
+          },
+        };
+
+        const result = firstPersonPlugin.onboarding!.disable!(cfg);
+
+        expect(result.channels?.firstperson?.enabled).toBe(false);
+        expect(result.channels?.firstperson?.token).toBe("fp_token_123");
+      });
+    });
+  });
+});