@wopr-network/platform-ui-core 1.0.0

package/src/__tests__/onboarding-data.test.ts

@@ -0,0 +1,363 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  channelPlugins,
+  collectConfigFields,
+  getAllPlugins,
+  getChannelPlugins,
+  getPluginById,
+  pluginCategories,
+  presets,
+  providerPlugins,
+  resolveDependencies,
+  validateField,
+} from "@/lib/onboarding-data";
+
+vi.mock("@/lib/marketplace-data", () => ({
+  listMarketplacePlugins: vi.fn().mockResolvedValue([
+    {
+      id: "discord",
+      name: "Discord",
+      description: "Discord channel",
+      icon: "MessageCircle",
+      color: "#5865F2",
+      category: "channel",
+      capabilities: ["channel"],
+      version: "1.0.0",
+      author: "Platform",
+      tags: [],
+      requires: [],
+      install: [],
+      configSchema: [],
+      setup: [],
+      installCount: 0,
+      changelog: [],
+    },
+    {
+      id: "slack",
+      name: "Slack",
+      description: "Slack channel",
+      icon: "Hash",
+      color: "#4A154B",
+      category: "channel",
+      capabilities: ["channel"],
+      version: "1.0.0",
+      author: "Platform",
+      tags: [],
+      requires: [],
+      install: [],
+      configSchema: [],
+      setup: [],
+      installCount: 0,
+      changelog: [],
+    },
+    {
+      id: "memory-plugin",
+      name: "Memory",
+      description: "Not a channel",
+      icon: "Brain",
+      color: "#10B981",
+      category: "memory",
+      capabilities: ["memory"],
+      version: "1.0.0",
+      author: "Platform",
+      tags: [],
+      requires: [],
+      install: [],
+      configSchema: [],
+      setup: [],
+      installCount: 0,
+      changelog: [],
+    },
+  ]),
+}));
+
+describe("onboarding-data", () => {
+  describe("channelPlugins", () => {
+    it("includes Signal, WhatsApp, MS Teams (onboarding-only channels; Discord/Slack/Telegram are marketplace-sourced via getChannelPlugins)", () => {
+      const ids = channelPlugins.map((p) => p.id);
+      expect(ids).toContain("signal");
+      expect(ids).toContain("whatsapp");
+      expect(ids).toContain("msteams");
+    });
+
+    it("all channels have capabilities including 'channel'", () => {
+      for (const ch of channelPlugins) {
+        expect(ch.capabilities).toContain("channel");
+      }
+    });
+
+    it("Signal has phone number config field", () => {
+      const signal = channelPlugins.find((p) => p.id === "signal");
+      expect(signal).toMatchObject({
+        id: "signal",
+        name: "Signal",
+        capabilities: ["channel"],
+        configFields: expect.arrayContaining([expect.objectContaining({ key: "signal_phone" })]),
+      });
+      const keys = signal?.configFields.map((f) => f.key);
+      expect(keys).toContain("signal_phone");
+    });
+
+    it("WhatsApp token is marked as secret", () => {
+      const whatsapp = channelPlugins.find((p) => p.id === "whatsapp");
+      const tokenField = whatsapp?.configFields.find((f) => f.key === "whatsapp_token");
+      expect(tokenField?.secret).toBe(true);
+    });
+  });
+
+  describe("providerPlugins", () => {
+    it("includes Anthropic, OpenAI, Kimi, OpenCode", () => {
+      const ids = providerPlugins.map((p) => p.id);
+      expect(ids).toContain("anthropic");
+      expect(ids).toContain("openai");
+      expect(ids).toContain("kimi");
+      expect(ids).toContain("opencode");
+    });
+
+    it("all providers have capabilities including 'provider'", () => {
+      for (const p of providerPlugins) {
+        expect(p.capabilities).toContain("provider");
+      }
+    });
+
+    it("Anthropic key validation requires sk-ant- prefix", () => {
+      const anthropic = providerPlugins.find((p) => p.id === "anthropic");
+      const keyField = anthropic?.configFields[0];
+      expect(keyField).toMatchObject({
+        key: "anthropic_api_key",
+        label: "Anthropic API Key",
+        secret: true,
+      });
+      expect(keyField?.validation?.pattern).toBe("^sk-ant-");
+    });
+  });
+
+  describe("pluginCategories", () => {
+    it("has memory, voice, integration, and ui categories", () => {
+      const ids = pluginCategories.map((c) => c.id);
+      expect(ids).toEqual(["memory", "voice", "integration", "ui"]);
+    });
+
+    it("voice category includes ElevenLabs TTS and Deepgram STT", () => {
+      const voice = pluginCategories.find((c) => c.id === "voice");
+      const ids = voice?.plugins.map((p) => p.id);
+      expect(ids).toContain("elevenlabs-tts");
+      expect(ids).toContain("deepgram-stt");
+    });
+
+    it("discord-voice requires discord", () => {
+      const voice = pluginCategories.find((c) => c.id === "voice");
+      const discordVoice = voice?.plugins.find((p) => p.id === "discord-voice");
+      expect(discordVoice?.requires).toContain("discord");
+    });
+  });
+
+  describe("presets", () => {
+    it("has 6 presets", () => {
+      expect(presets).toHaveLength(6);
+    });
+
+    it("discord-ai-bot preset selects discord + anthropic + memory", () => {
+      const preset = presets.find((p) => p.id === "discord-ai-bot");
+      expect(preset).toMatchObject({
+        id: "discord-ai-bot",
+        name: "Discord AI Bot",
+        channels: ["discord"],
+        providers: ["anthropic"],
+        plugins: ["semantic-memory"],
+        keyCount: 2,
+      });
+      expect(preset?.channels).toEqual(["discord"]);
+      expect(preset?.providers).toEqual(["anthropic"]);
+      expect(preset?.plugins).toEqual(["semantic-memory"]);
+      expect(preset?.keyCount).toBe(2);
+    });
+
+    it("custom preset has empty selections", () => {
+      const custom = presets.find((p) => p.id === "custom");
+      expect(custom).toMatchObject({
+        id: "custom",
+        name: "Custom",
+        channels: [],
+        providers: [],
+        plugins: [],
+      });
+      expect(custom?.channels).toEqual([]);
+      expect(custom?.providers).toEqual([]);
+      expect(custom?.plugins).toEqual([]);
+    });
+
+    it("voice-enabled preset includes voice plugins", () => {
+      const preset = presets.find((p) => p.id === "voice-enabled");
+      expect(preset?.plugins).toContain("elevenlabs-tts");
+      expect(preset?.plugins).toContain("deepgram-stt");
+      expect(preset?.plugins).toContain("discord-voice");
+    });
+  });
+
+  describe("getAllPlugins", () => {
+    it("returns all plugins from all categories", () => {
+      const all = getAllPlugins();
+      expect(all.length).toBeGreaterThan(10);
+      // Should include onboarding-only channels, providers, and optional plugins
+      // (Discord/Slack/Telegram are marketplace-sourced via getChannelPlugins, not in static list)
+      expect(all.map((p) => p.id)).toContain("signal");
+      expect(all.map((p) => p.id)).toContain("anthropic");
+      expect(all.map((p) => p.id)).toContain("semantic-memory");
+    });
+  });
+
+  describe("getPluginById", () => {
+    it("returns a plugin by id", () => {
+      const signal = getPluginById("signal");
+      expect(signal?.name).toBe("Signal");
+    });
+
+    it("returns undefined for unknown id", () => {
+      expect(getPluginById("nonexistent")).toBeUndefined();
+    });
+  });
+
+  describe("collectConfigFields", () => {
+    it("collects fields from selected channels, providers, and plugins", () => {
+      const fields = collectConfigFields(["signal"], ["anthropic"], ["elevenlabs-tts"]);
+      const keys = fields.map((f) => f.key);
+      expect(keys).toContain("signal_phone");
+      expect(keys).toContain("anthropic_api_key");
+      expect(keys).toContain("elevenlabs_api_key");
+    });
+
+    it("deduplicates fields by key", () => {
+      const fields = collectConfigFields(["signal", "signal"], ["anthropic"], []);
+      const phoneFields = fields.filter((f) => f.key === "signal_phone");
+      expect(phoneFields).toHaveLength(1);
+    });
+
+    it("returns empty array for no selections", () => {
+      const fields = collectConfigFields([], [], []);
+      expect(fields).toHaveLength(0);
+    });
+
+    it("handles plugins with no config fields", () => {
+      const fields = collectConfigFields([], [], ["semantic-memory"]);
+      expect(fields).toHaveLength(0);
+    });
+  });
+
+  describe("resolveDependencies", () => {
+    it("returns selected plugins when no dependencies needed", () => {
+      const resolved = resolveDependencies(["discord"], ["anthropic"], ["semantic-memory"]);
+      expect(resolved).toContain("semantic-memory");
+    });
+
+    it("does not duplicate existing channel/provider when resolving requires", () => {
+      // discord-voice requires discord, but discord is already in channels
+      const resolved = resolveDependencies(["discord"], ["anthropic"], ["discord-voice"]);
+      expect(resolved).toContain("discord-voice");
+      // discord should NOT be added as a plugin since it is already a channel
+      const discordCount = resolved.filter((id) => id === "discord").length;
+      expect(discordCount).toBe(0);
+    });
+
+    it("adds dependency as plugin if not in channels or providers", () => {
+      // discord-voice requires discord, but discord is NOT selected
+      const resolved = resolveDependencies([], ["anthropic"], ["discord-voice"]);
+      expect(resolved).toContain("discord-voice");
+      expect(resolved).toContain("discord");
+    });
+  });
+
+  describe("validateField", () => {
+    it("returns error for empty value", () => {
+      const field = {
+        key: "test",
+        label: "Test Key",
+        secret: true,
+      };
+      expect(validateField(field, "")).toBe("Test Key is required");
+      expect(validateField(field, "   ")).toBe("Test Key is required");
+    });
+
+    it("returns null for valid value without pattern", () => {
+      const field = {
+        key: "test",
+        label: "Test Key",
+        secret: true,
+      };
+      expect(validateField(field, "some-value")).toBeNull();
+    });
+
+    it("validates against pattern", () => {
+      const field = {
+        key: "anthropic_api_key",
+        label: "Anthropic API Key",
+        secret: true,
+        validation: { pattern: "^sk-ant-", message: "Must start with sk-ant-" },
+      };
+      expect(validateField(field, "sk-ant-abc123")).toBeNull();
+      expect(validateField(field, "sk-wrong")).toBe("Must start with sk-ant-");
+    });
+
+    it("returns validation message for invalid pattern", () => {
+      const field = {
+        key: "telegram_bot_token",
+        label: "Telegram Bot Token",
+        secret: true,
+        validation: { pattern: "^[0-9]+:[A-Za-z0-9_-]+$", message: "Invalid Telegram token" },
+      };
+      expect(validateField(field, "123:ABC_def")).toBeNull();
+      expect(validateField(field, "invalid token!")).toBe("Invalid Telegram token");
+    });
+  });
+
+  describe("getChannelPlugins", () => {
+    it("returns marketplace channels merged with onboarding-only channels", async () => {
+      const channels = await getChannelPlugins();
+      const ids = channels.map((c) => c.id);
+      // Marketplace channels
+      expect(ids).toContain("discord");
+      expect(ids).toContain("slack");
+      // Onboarding-only channels
+      expect(ids).toContain("signal");
+      expect(ids).toContain("whatsapp");
+      expect(ids).toContain("msteams");
+      // Non-channel plugins excluded
+      expect(ids).not.toContain("memory-plugin");
+    });
+
+    it("applies CHANNEL_OVERLAY config fields to marketplace channels", async () => {
+      const channels = await getChannelPlugins();
+      const discord = channels.find((c) => c.id === "discord");
+      expect(discord).toMatchObject({
+        id: "discord",
+        name: "Discord",
+        capabilities: ["channel"],
+      });
+      const keys = discord?.configFields.map((f) => f.key);
+      expect(keys).toContain("discord_bot_token");
+      expect(keys).toContain("discord_guild_id");
+    });
+
+    it("applies CHANNEL_OVERLAY diyCostData to marketplace channels", async () => {
+      const channels = await getChannelPlugins();
+      const discord = channels.find((c) => c.id === "discord");
+      expect(discord?.diyCostData).toMatchObject({
+        diyLabel: "Discord bot hosting",
+        diyCostPerMonth: "$5-20/mo",
+        diyCostNumeric: 1200,
+      });
+      expect(discord?.diyCostData?.diyLabel).toBe("Discord bot hosting");
+    });
+
+    it("marketplace channels with overlay get their config fields", async () => {
+      const channels = await getChannelPlugins();
+      const slack = channels.find((c) => c.id === "slack");
+      expect(slack).toMatchObject({
+        id: "slack",
+        name: "Slack",
+        capabilities: ["channel"],
+      });
+      expect(slack?.configFields.length).toBeGreaterThan(0);
+    });
+  });
+});

package/src/__tests__/onboarding-page.test.tsx

@@ -0,0 +1,113 @@
+import { render, screen, waitFor } from "@testing-library/react";
+import userEvent from "@testing-library/user-event";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+const mockPush = vi.fn();
+vi.mock("next/navigation", () => ({
+  useRouter: () => ({ push: mockPush }),
+}));
+
+vi.mock("framer-motion", () => ({
+  motion: {
+    div: ({ children, ...props }: React.HTMLAttributes<HTMLDivElement>) => (
+      <div {...props}>{children}</div>
+    ),
+  },
+  AnimatePresence: ({ children }: { children: React.ReactNode }) => <>{children}</>,
+}));
+
+const mockMarkComplete = vi.fn();
+const mockSaveState = vi.fn();
+let mockIsComplete = false;
+
+vi.mock("@/lib/onboarding-store", () => ({
+  isOnboardingComplete: () => mockIsComplete,
+  markOnboardingComplete: (...args: unknown[]) => mockMarkComplete(...args),
+  saveOnboardingState: (...args: unknown[]) => mockSaveState(...args),
+  loadOnboardingState: () => ({
+    currentStep: 0,
+    providers: [],
+    channels: [],
+    channelsConfigured: [],
+    channelConfigs: {},
+    plugins: ["memory"],
+    instanceName: "",
+  }),
+}));
+
+vi.mock("@/lib/onboarding-data", () => ({
+  presets: [
+    {
+      id: "discord-ai-bot",
+      name: "Discord AI Bot",
+      description: "A Discord bot powered by Claude.",
+      channels: ["discord"],
+      providers: ["anthropic"],
+      plugins: ["semantic-memory"],
+      keyCount: 2,
+    },
+    {
+      id: "custom",
+      name: "Custom",
+      description: "Full wizard.",
+      channels: [],
+      providers: [],
+      plugins: [],
+      keyCount: 0,
+    },
+  ],
+}));
+
+import OnboardingPage from "@/app/(dashboard)/onboarding/page";
+
+describe("OnboardingPage", () => {
+  beforeEach(() => {
+    mockPush.mockClear();
+    mockMarkComplete.mockClear();
+    mockSaveState.mockClear();
+    mockIsComplete = false;
+  });
+
+  it("renders step 1 — name your bot", () => {
+    render(<OnboardingPage />);
+    expect(screen.getByText(/name your/i)).toBeInTheDocument();
+    expect(screen.getByRole("textbox")).toBeInTheDocument();
+  });
+
+  it("redirects to /marketplace if onboarding already complete", async () => {
+    mockIsComplete = true;
+    render(<OnboardingPage />);
+    await waitFor(() => {
+      expect(mockPush).toHaveBeenCalledWith("/marketplace");
+    });
+  });
+
+  it("advances to step 2 after entering a name", async () => {
+    const user = userEvent.setup();
+    render(<OnboardingPage />);
+    const input = screen.getByRole("textbox");
+    await user.type(input, "My Bot");
+    await user.click(screen.getByRole("button", { name: /next/i }));
+    expect(screen.getByText(/pick a preset/i)).toBeInTheDocument();
+  });
+
+  it("completes onboarding and redirects to marketplace", async () => {
+    const user = userEvent.setup();
+    render(<OnboardingPage />);
+
+    // Step 1: name
+    await user.type(screen.getByRole("textbox"), "My Bot");
+    await user.click(screen.getByRole("button", { name: /next/i }));
+
+    // Step 2: pick preset
+    await user.click(screen.getByText("Discord AI Bot"));
+    await user.click(screen.getByRole("button", { name: /next/i }));
+
+    // Step 3: confirm & launch
+    await user.click(screen.getByRole("button", { name: /launch/i }));
+
+    expect(mockMarkComplete).toHaveBeenCalled();
+    expect(mockSaveState).toHaveBeenCalled();
+    expect(mockPush).toHaveBeenCalledWith("/marketplace");
+  });
+});

package/src/__tests__/onboarding-store.test.ts

@@ -0,0 +1,121 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import {
+  clearOnboardingState,
+  loadOnboardingState,
+  type OnboardingState,
+  saveOnboardingState,
+} from "../lib/onboarding-store";
+
+beforeEach(() => {
+  localStorage.clear();
+});
+
+describe("saveOnboardingState", () => {
+  it("persists state to localStorage with secrets stripped", () => {
+    const state: OnboardingState = {
+      currentStep: 2,
+      providers: [{ id: "anthropic", name: "Anthropic", key: "sk-ant-xxx", validated: true }],
+      channels: ["discord"],
+      channelsConfigured: ["discord"],
+      channelConfigs: { discord: { token: "abc" } },
+      plugins: ["memory", "voice"],
+      instanceName: "test-bot",
+    };
+    saveOnboardingState(state);
+    const raw = localStorage.getItem("platform-onboarding");
+    expect(raw).not.toBeNull();
+    const parsed = JSON.parse(raw ?? "null");
+    expect(parsed.currentStep).toBe(2);
+    expect(parsed.instanceName).toBe("test-bot");
+    expect(parsed.channels).toEqual(["discord"]);
+    expect(parsed.providers[0].key).toBeUndefined();
+    expect(parsed.providers[0].validated).toBe(false);
+    expect((parsed as Record<string, unknown>).channelConfigs).toBeUndefined();
+  });
+
+  it("strips provider API keys before persisting", () => {
+    const state: OnboardingState = {
+      currentStep: 2,
+      providers: [
+        { id: "anthropic", name: "Anthropic", key: "sk-ant-secret", validated: true },
+        { id: "openai", name: "OpenAI", key: "sk-proj-secret", validated: true },
+      ],
+      channels: ["discord"],
+      channelsConfigured: ["discord"],
+      channelConfigs: { discord: { token: "discord-bot-token" } },
+      plugins: ["memory"],
+      instanceName: "test-bot",
+    };
+    saveOnboardingState(state);
+    const raw = JSON.parse(localStorage.getItem("platform-onboarding") ?? "{}");
+    for (const p of raw.providers) {
+      expect(p.key).toBeUndefined();
+      expect(p.validated).toBe(false);
+    }
+    expect((raw as Record<string, unknown>).channelConfigs).toBeUndefined();
+  });
+
+  it("does not mutate the original state object", () => {
+    const state: OnboardingState = {
+      currentStep: 1,
+      providers: [{ id: "anthropic", name: "Anthropic", key: "sk-ant-xxx", validated: true }],
+      channels: [],
+      channelsConfigured: [],
+      channelConfigs: { discord: { token: "abc" } },
+      plugins: ["memory"],
+      instanceName: "",
+    };
+    saveOnboardingState(state);
+    expect(state.providers[0].key).toBe("sk-ant-xxx");
+    expect(state.providers[0].validated).toBe(true);
+    expect(state.channelConfigs.discord.token).toBe("abc");
+  });
+
+  it("round-trips non-secret fields correctly after stripping", () => {
+    const state: OnboardingState = {
+      currentStep: 3,
+      providers: [{ id: "anthropic", name: "Anthropic", key: "sk-ant-xxx", validated: true }],
+      channels: ["discord", "slack"],
+      channelsConfigured: ["discord"],
+      channelConfigs: { discord: { token: "secret" } },
+      plugins: ["memory", "voice"],
+      instanceName: "my-bot",
+    };
+    saveOnboardingState(state);
+    const loaded = loadOnboardingState();
+    expect(loaded.currentStep).toBe(3);
+    expect(loaded.channels).toEqual(["discord", "slack"]);
+    expect(loaded.instanceName).toBe("my-bot");
+    expect(loaded.plugins).toEqual(["memory", "voice"]);
+    expect(loaded.providers[0].id).toBe("anthropic");
+    expect(loaded.providers[0].name).toBe("Anthropic");
+    expect(loaded.providers[0].key).toBe("");
+    expect(loaded.providers[0].validated).toBe(false);
+  });
+});
+
+describe("loadOnboardingState", () => {
+  it("returns default state when nothing persisted", () => {
+    const state = loadOnboardingState();
+    expect(state.currentStep).toBe(0);
+    expect(state.providers).toEqual([]);
+    expect(state.plugins).toEqual(["memory"]);
+  });
+});
+
+describe("clearOnboardingState", () => {
+  it("removes persisted state", () => {
+    const state: OnboardingState = {
+      currentStep: 1,
+      providers: [],
+      channels: [],
+      channelsConfigured: [],
+      channelConfigs: {},
+      plugins: [],
+      instanceName: "bot",
+    };
+    saveOnboardingState(state);
+    clearOnboardingState();
+    expect(localStorage.getItem("platform-onboarding")).toBeNull();
+  });
+});

package/src/__tests__/org-billing-api.test.tsx

@@ -0,0 +1,70 @@
+import { describe, expect, it, vi } from "vitest";
+
+vi.mock("@/lib/trpc", () => ({
+  trpcVanilla: {
+    org: {
+      orgBillingBalance: {
+        query: vi.fn().mockResolvedValue({
+          orgId: "org-1",
+          balanceCents: 5000,
+          dailyBurnCents: 100,
+          runwayDays: 50,
+        }),
+      },
+      orgMemberUsage: {
+        query: vi.fn().mockResolvedValue({
+          orgId: "org-1",
+          periodStart: "2026-02-01T00:00:00.000Z",
+          members: [],
+        }),
+      },
+      orgBillingInfo: {
+        query: vi.fn().mockResolvedValue({ paymentMethods: [], invoices: [] }),
+      },
+      orgTopupCheckout: {
+        mutate: vi.fn().mockResolvedValue({
+          url: "https://checkout.stripe.com/test",
+          sessionId: "sess_1",
+        }),
+      },
+    },
+  },
+}));
+
+import {
+  createOrgTopupCheckout,
+  getOrgBillingInfo,
+  getOrgCreditBalance,
+  getOrgMemberUsage,
+} from "@/lib/org-billing-api";
+
+describe("org-billing-api", () => {
+  it("getOrgCreditBalance converts cents to dollars", async () => {
+    const result = await getOrgCreditBalance("org-1");
+    expect(result.balance).toBe(50);
+    expect(result.dailyBurn).toBe(1);
+    expect(result.runway).toBe(50);
+  });
+
+  it("getOrgMemberUsage returns member array", async () => {
+    const result = await getOrgMemberUsage("org-1");
+    expect(result.orgId).toBe("org-1");
+    expect(Array.isArray(result.members)).toBe(true);
+  });
+
+  it("getOrgBillingInfo returns payment methods and invoices", async () => {
+    const result = await getOrgBillingInfo("org-1");
+    expect(result).toHaveProperty("paymentMethods");
+    expect(result).toHaveProperty("invoices");
+  });
+
+  it("createOrgTopupCheckout returns checkout URL", async () => {
+    const result = await createOrgTopupCheckout(
+      "org-1",
+      "price_1",
+      "https://ok.com",
+      "https://cancel.com",
+    );
+    expect(result.url).toContain("stripe.com");
+  });
+});