@wopr-network/platform-core 1.0.10 → 1.1.0

package/dist/fleet/bot-authorization.js

@@ -0,0 +1,16 @@
+/**
+ * Check if a user with the given role can manage (control/update/destroy) a bot.
+ *
+ * - platform_admin / tenant_admin: can manage any bot in the tenant
+ * - user: can only manage bots they created (createdByUserId matches)
+ * - null role or unknown: denied
+ */
+export function canManageBot(userRole, userId, botCreatedByUserId) {
+    if (userRole === "platform_admin" || userRole === "tenant_admin") {
+        return true;
+    }
+    if (userRole === "user" && botCreatedByUserId !== null) {
+        return userId === botCreatedByUserId;
+    }
+    return false;
+}

package/dist/fleet/bot-authorization.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fleet/bot-authorization.test.js

@@ -0,0 +1,25 @@
+import { describe, expect, it } from "vitest";
+import { canManageBot } from "./bot-authorization.js";
+describe("canManageBot", () => {
+    it("tenant_admin can manage any bot in their tenant", () => {
+        expect(canManageBot("tenant_admin", "admin-1", "other-user")).toBe(true);
+    });
+    it("tenant_admin can manage legacy bots (null creator)", () => {
+        expect(canManageBot("tenant_admin", "admin-1", null)).toBe(true);
+    });
+    it("platform_admin can manage any bot", () => {
+        expect(canManageBot("platform_admin", "pa-1", "some-user")).toBe(true);
+    });
+    it("user can manage their own bot", () => {
+        expect(canManageBot("user", "user-1", "user-1")).toBe(true);
+    });
+    it("user cannot manage another user's bot", () => {
+        expect(canManageBot("user", "user-1", "user-2")).toBe(false);
+    });
+    it("user cannot manage legacy bot (null creator)", () => {
+        expect(canManageBot("user", "user-1", null)).toBe(false);
+    });
+    it("null role (no role assigned) cannot manage any bot", () => {
+        expect(canManageBot(null, "user-1", "user-1")).toBe(false);
+    });
+});

package/dist/fleet/bot-instance-repository.d.ts

@@ -0,0 +1,41 @@
+import type { BillingState, BotInstance, NewBotInstance, TenantWithTier } from "./repository-types.js";
+export type { BillingState, BotInstance, NewBotInstance, TenantWithTier };
+/** Repository interface for bot instance operations. */
+export interface IBotInstanceRepository {
+    getById(id: string): Promise<BotInstance | null>;
+    listByNode(nodeId: string): Promise<BotInstance[]>;
+    listByTenant(tenantId: string): Promise<BotInstance[]>;
+    create(data: NewBotInstance): Promise<BotInstance>;
+    reassign(id: string, nodeId: string | null): Promise<BotInstance>;
+    setBillingState(id: string, state: BillingState): Promise<BotInstance>;
+    getResourceTier(botId: string): Promise<string | null>;
+    setResourceTier(botId: string, tier: string): Promise<void>;
+    deleteAllByTenant(tenantId: string): Promise<void>;
+    deleteById(instanceId: string): Promise<void>;
+    /** List bot instances on a node with tier priority (enterprise > pro > starter > free). */
+    listByNodeWithTier(nodeId: string): Promise<TenantWithTier[]>;
+    /** Find a bot instance by tenant ID and node ID. */
+    findByTenantAndNode(tenantId: string, nodeId: string): Promise<BotInstance | null>;
+    /** Count active bots for a tenant. */
+    countActiveByTenant(tenantId: string): Promise<number>;
+    /** List active bot IDs for a tenant. */
+    listActiveIdsByTenant(tenantId: string): Promise<string[]>;
+    /** List suspended bot IDs for a tenant. */
+    listSuspendedIdsByTenant(tenantId: string): Promise<string[]>;
+    /** List IDs of suspended bots past their destroy_after deadline. */
+    listExpiredSuspendedIds(): Promise<string[]>;
+    /** Update billing fields for suspension. */
+    suspend(botId: string, graceDays: number): Promise<void>;
+    /** Clear suspension and reactivate. */
+    reactivate(botId: string): Promise<void>;
+    /** Mark a bot as destroyed. */
+    markDestroyed(botId: string): Promise<void>;
+    /** Register a new bot instance. */
+    register(botId: string, tenantId: string, name: string): Promise<void>;
+    /** Get storage tier for a bot. */
+    getStorageTier(botId: string): Promise<string | null>;
+    /** Set storage tier for a bot. */
+    setStorageTier(botId: string, tier: string): Promise<void>;
+    /** List storage tiers for all active bots of a tenant. */
+    listActiveStorageTiers(tenantId: string): Promise<string[]>;
+}

package/dist/fleet/bot-instance-repository.js

@@ -0,0 +1 @@
+export {};

package/dist/fleet/bot-instance-repository.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fleet/bot-instance-repository.test.js

@@ -0,0 +1,264 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleBotInstanceRepository } from "./drizzle-bot-instance-repository.js";
+describe("DrizzleBotInstanceRepository", () => {
+    let db;
+    let pool;
+    let repo;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+        await beginTestTransaction(pool);
+    });
+    afterAll(async () => {
+        await endTestTransaction(pool);
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await rollbackTestTransaction(pool);
+        repo = new DrizzleBotInstanceRepository(db);
+    });
+    describe("create", () => {
+        it("creates a bot instance with default billing state", async () => {
+            const bot = await repo.create({
+                id: "bot-1",
+                tenantId: "tenant-1",
+                name: "my-bot",
+                nodeId: "node-1",
+            });
+            expect(bot.id).toBe("bot-1");
+            expect(bot.tenantId).toBe("tenant-1");
+            expect(bot.name).toBe("my-bot");
+            expect(bot.nodeId).toBe("node-1");
+            expect(bot.billingState).toBe("active");
+            expect(bot.suspendedAt).toBeNull();
+            expect(bot.destroyAfter).toBeNull();
+            expect(bot.createdAt).toEqual(expect.any(String));
+            expect(bot.updatedAt).toEqual(expect.any(String));
+        });
+        it("creates a bot instance with explicit billing state", async () => {
+            const bot = await repo.create({
+                id: "bot-2",
+                tenantId: "tenant-1",
+                name: "suspended-bot",
+                nodeId: null,
+                billingState: "suspended",
+            });
+            expect(bot.billingState).toBe("suspended");
+        });
+        it("creates a bot instance with null nodeId", async () => {
+            const bot = await repo.create({
+                id: "bot-3",
+                tenantId: "tenant-1",
+                name: "unassigned-bot",
+                nodeId: null,
+            });
+            expect(bot.nodeId).toBeNull();
+        });
+    });
+    describe("getById", () => {
+        it("returns the bot instance when it exists", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b", nodeId: "n-1" });
+            const bot = await repo.getById("bot-1");
+            expect(bot).not.toBeNull();
+            expect(bot?.id).toBe("bot-1");
+        });
+        it("returns null when bot does not exist", async () => {
+            expect(await repo.getById("nonexistent")).toBeNull();
+        });
+    });
+    describe("listByNode", () => {
+        it("returns all instances on a node", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "node-A" });
+            await repo.create({ id: "bot-2", tenantId: "t-2", name: "b2", nodeId: "node-A" });
+            await repo.create({ id: "bot-3", tenantId: "t-3", name: "b3", nodeId: "node-B" });
+            const result = await repo.listByNode("node-A");
+            expect(result).toHaveLength(2);
+            expect(result.map((b) => b.id).sort()).toEqual(["bot-1", "bot-2"]);
+        });
+        it("returns empty array when no instances on node", async () => {
+            expect(await repo.listByNode("empty-node")).toEqual([]);
+        });
+        it("does not return instances with null nodeId", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: null });
+            expect(await repo.listByNode("any-node")).toEqual([]);
+        });
+    });
+    describe("listByTenant", () => {
+        it("returns all instances for a tenant", async () => {
+            await repo.create({ id: "bot-1", tenantId: "tenant-X", name: "b1", nodeId: "n-1" });
+            await repo.create({ id: "bot-2", tenantId: "tenant-X", name: "b2", nodeId: "n-2" });
+            await repo.create({ id: "bot-3", tenantId: "tenant-Y", name: "b3", nodeId: "n-1" });
+            const result = await repo.listByTenant("tenant-X");
+            expect(result).toHaveLength(2);
+            expect(result.every((b) => b.tenantId === "tenant-X")).toBe(true);
+        });
+        it("returns empty array when tenant has no instances", async () => {
+            expect(await repo.listByTenant("nobody")).toEqual([]);
+        });
+    });
+    describe("reassign", () => {
+        it("updates nodeId and returns updated instance", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "node-old" });
+            const updated = await repo.reassign("bot-1", "node-new");
+            expect(updated.nodeId).toBe("node-new");
+            expect(updated.id).toBe("bot-1");
+        });
+        it("updates updatedAt timestamp", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "node-old" });
+            const updated = await repo.reassign("bot-1", "node-new");
+            expect(updated.updatedAt).toEqual(expect.any(String));
+        });
+        it("throws when bot does not exist", async () => {
+            await expect(repo.reassign("nonexistent", "node-1")).rejects.toThrow("Bot instance not found: nonexistent");
+        });
+    });
+    describe("createdByUserId", () => {
+        it("persists createdByUserId on create", async () => {
+            const bot = await repo.create({
+                id: "00000000-0000-4000-8000-000000000099",
+                tenantId: "tenant-1",
+                name: "test-bot",
+                nodeId: null,
+                createdByUserId: "user-42",
+            });
+            expect(bot.createdByUserId).toBe("user-42");
+        });
+        it("defaults createdByUserId to null when omitted", async () => {
+            const bot = await repo.create({
+                id: "00000000-0000-4000-8000-000000000098",
+                tenantId: "tenant-1",
+                name: "legacy-bot",
+                nodeId: null,
+            });
+            expect(bot.createdByUserId).toBeNull();
+        });
+        it("returns createdByUserId from getById", async () => {
+            await repo.create({
+                id: "00000000-0000-4000-8000-000000000097",
+                tenantId: "tenant-1",
+                name: "owned-bot",
+                nodeId: null,
+                createdByUserId: "user-7",
+            });
+            const fetched = await repo.getById("00000000-0000-4000-8000-000000000097");
+            expect(fetched?.createdByUserId).toBe("user-7");
+        });
+        it("returns createdByUserId in listByTenant", async () => {
+            await repo.create({
+                id: "00000000-0000-4000-8000-000000000096",
+                tenantId: "tenant-2",
+                name: "org-bot",
+                nodeId: null,
+                createdByUserId: "user-A",
+            });
+            const bots = await repo.listByTenant("tenant-2");
+            expect(bots[0].createdByUserId).toBe("user-A");
+        });
+    });
+    describe("org-scoped ownership (WOP-1002)", () => {
+        it("bot persists after removing the creating user (no FK cascade)", async () => {
+            await repo.create({
+                id: "00000000-0000-4000-8000-000000000090",
+                tenantId: "org-tenant-1",
+                name: "org-bot-1",
+                nodeId: null,
+                createdByUserId: "user-A",
+            });
+            // Simulate removing user-A: just verify bot still exists
+            // (There is no FK from bot_instances to users, so nothing cascades)
+            const bot = await repo.getById("00000000-0000-4000-8000-000000000090");
+            expect(bot).not.toBeNull();
+            expect(bot?.tenantId).toBe("org-tenant-1");
+            expect(bot?.createdByUserId).toBe("user-A");
+        });
+        it("listByTenant returns bots from all creators in the org", async () => {
+            await repo.create({
+                id: "00000000-0000-4000-8000-000000000089",
+                tenantId: "org-tenant-2",
+                name: "bot-by-A",
+                nodeId: null,
+                createdByUserId: "user-A",
+            });
+            await repo.create({
+                id: "00000000-0000-4000-8000-000000000088",
+                tenantId: "org-tenant-2",
+                name: "bot-by-B",
+                nodeId: null,
+                createdByUserId: "user-B",
+            });
+            const bots = await repo.listByTenant("org-tenant-2");
+            expect(bots).toHaveLength(2);
+            const creators = bots.map((b) => b.createdByUserId).sort();
+            expect(creators).toEqual(["user-A", "user-B"]);
+        });
+    });
+    describe("getResourceTier / setResourceTier", () => {
+        it("returns the default 'standard' tier when none has been explicitly set", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            expect(await repo.getResourceTier("bot-1")).toBe("standard");
+        });
+        it("sets and gets resource tier", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            await repo.setResourceTier("bot-1", "gpu-large");
+            expect(await repo.getResourceTier("bot-1")).toBe("gpu-large");
+        });
+        it("overwrites existing resource tier", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            await repo.setResourceTier("bot-1", "gpu-small");
+            await repo.setResourceTier("bot-1", "gpu-large");
+            expect(await repo.getResourceTier("bot-1")).toBe("gpu-large");
+        });
+    });
+    describe("deleteAllByTenant", () => {
+        it("deletes all bots for a tenant", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            await repo.create({ id: "bot-2", tenantId: "t-1", name: "b2", nodeId: "n-1" });
+            await repo.create({ id: "bot-3", tenantId: "t-2", name: "b3", nodeId: "n-1" });
+            await repo.deleteAllByTenant("t-1");
+            expect(await repo.listByTenant("t-1")).toEqual([]);
+            expect(await repo.listByTenant("t-2")).toHaveLength(1);
+        });
+        it("does nothing when tenant has no bots", async () => {
+            await repo.deleteAllByTenant("nonexistent");
+            // No error thrown
+        });
+    });
+    describe("deleteById", () => {
+        it("deletes a single bot instance by id", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            await repo.create({ id: "bot-2", tenantId: "t-1", name: "b2", nodeId: "n-1" });
+            await repo.deleteById("bot-1");
+            expect(await repo.getById("bot-1")).toBeNull();
+            expect(await repo.getById("bot-2")).not.toBeNull();
+        });
+        it("does nothing when id does not exist", async () => {
+            await repo.deleteById("nonexistent");
+            // No error thrown
+        });
+    });
+    describe("setBillingState", () => {
+        it("suspends a bot and sets suspension timestamps", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            const suspended = await repo.setBillingState("bot-1", "suspended");
+            expect(suspended.billingState).toBe("suspended");
+            expect(suspended.suspendedAt).not.toBeNull();
+            expect(suspended.destroyAfter).not.toBeNull();
+        });
+        it("reactivates a bot and clears suspension timestamps", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            await repo.setBillingState("bot-1", "suspended");
+            const reactivated = await repo.setBillingState("bot-1", "active");
+            expect(reactivated.billingState).toBe("active");
+            expect(reactivated.suspendedAt).toBeNull();
+            expect(reactivated.destroyAfter).toBeNull();
+        });
+        it("sets billing state to destroyed", async () => {
+            await repo.create({ id: "bot-1", tenantId: "t-1", name: "b1", nodeId: "n-1" });
+            const destroyed = await repo.setBillingState("bot-1", "destroyed");
+            expect(destroyed.billingState).toBe("destroyed");
+        });
+        it("throws when bot does not exist", async () => {
+            await expect(repo.setBillingState("nonexistent", "suspended")).rejects.toThrow("Bot instance not found: nonexistent");
+        });
+    });
+});

package/dist/fleet/bot-profile-repository.d.ts

@@ -0,0 +1,11 @@
+import type { BotProfile } from "./types.js";
+/**
+ * Repository interface for bot profiles.
+ * Replaces the YAML-based ProfileStore.
+ */
+export interface IBotProfileRepository {
+    get(id: string): Promise<BotProfile | null>;
+    save(profile: BotProfile): Promise<BotProfile>;
+    delete(id: string): Promise<boolean>;
+    list(): Promise<BotProfile[]>;
+}

package/dist/fleet/bot-profile-repository.js

@@ -0,0 +1 @@
+export {};

package/dist/fleet/bot-profile-repository.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fleet/bot-profile-repository.test.js

@@ -0,0 +1,132 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleBotProfileRepository } from "./drizzle-bot-profile-repository.js";
+const TEST_IMAGE = "ghcr.io/wopr-network/test:latest";
+function makeProfile(overrides = {}) {
+    return {
+        id: "aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee",
+        tenantId: "tenant-1",
+        name: "test-bot",
+        description: "A test bot",
+        image: TEST_IMAGE,
+        env: { FOO: "bar", BAZ: "qux" },
+        restartPolicy: "unless-stopped",
+        releaseChannel: "stable",
+        updatePolicy: "manual",
+        ...overrides,
+    };
+}
+describe("DrizzleBotProfileRepository", () => {
+    let db;
+    let pool;
+    let repo;
+    beforeAll(async () => {
+        ({ db, pool } = await createTestDb());
+        await beginTestTransaction(pool);
+    });
+    afterAll(async () => {
+        await endTestTransaction(pool);
+        await pool.close();
+    });
+    beforeEach(async () => {
+        await rollbackTestTransaction(pool);
+        repo = new DrizzleBotProfileRepository(db);
+    });
+    describe("get()", () => {
+        it("returns null when not found", async () => {
+            const result = await repo.get("nonexistent-id");
+            expect(result).toBeNull();
+        });
+        it("returns parsed profile with env as object (not string)", async () => {
+            const profile = makeProfile();
+            await repo.save(profile);
+            const result = await repo.get(profile.id);
+            expect(result).not.toBeNull();
+            expect(result?.env).toEqual({ FOO: "bar", BAZ: "qux" });
+            expect(typeof result?.env).toBe("object");
+            expect(typeof result?.env).not.toBe("string");
+        });
+        it("returns profile with all fields matching", async () => {
+            const profile = makeProfile({
+                volumeName: "my-volume",
+                discovery: { enabled: true, topics: ["wopr-org-test"] },
+            });
+            await repo.save(profile);
+            const result = await repo.get(profile.id);
+            expect(result).toEqual(profile);
+        });
+        it("returns profile with optional fields as undefined when not set", async () => {
+            const profile = makeProfile(); // no volumeName, no discovery
+            await repo.save(profile);
+            const result = await repo.get(profile.id);
+            expect(result?.volumeName).toBeUndefined();
+            expect(result?.discovery).toBeUndefined();
+        });
+    });
+    describe("save()", () => {
+        it("inserts a new profile", async () => {
+            const profile = makeProfile();
+            const result = await repo.save(profile);
+            expect(result).toEqual(profile);
+            expect(await repo.get(profile.id)).toEqual(profile);
+        });
+        it("upserts an existing profile (updates on conflict)", async () => {
+            const profile = makeProfile();
+            await repo.save(profile);
+            const updated = { ...profile, name: "updated-bot", image: TEST_IMAGE };
+            await repo.save(updated);
+            const result = await repo.get(profile.id);
+            expect(result?.name).toBe("updated-bot");
+        });
+        it("handles empty env object", async () => {
+            const profile = makeProfile({ env: {} });
+            await repo.save(profile);
+            const result = await repo.get(profile.id);
+            expect(result?.env).toEqual({});
+        });
+        it("preserves discovery config through round-trip", async () => {
+            const profile = makeProfile({
+                discovery: { enabled: false, topics: ["topic-a", "topic-b"] },
+            });
+            await repo.save(profile);
+            const result = await repo.get(profile.id);
+            expect(result?.discovery).toEqual({ enabled: false, topics: ["topic-a", "topic-b"] });
+        });
+    });
+    describe("delete()", () => {
+        it("returns true when profile exists and is deleted", async () => {
+            const profile = makeProfile();
+            await repo.save(profile);
+            expect(await repo.delete(profile.id)).toBe(true);
+            expect(await repo.get(profile.id)).toBeNull();
+        });
+        it("returns false when profile does not exist", async () => {
+            expect(await repo.delete("nonexistent-id")).toBe(false);
+        });
+    });
+    describe("list()", () => {
+        it("returns empty array when no profiles", async () => {
+            expect(await repo.list()).toEqual([]);
+        });
+        it("returns all saved profiles", async () => {
+            const p1 = makeProfile({ id: "aaaaaaaa-1111-1111-1111-111111111111", name: "bot-1" });
+            const p2 = makeProfile({
+                id: "bbbbbbbb-2222-2222-2222-222222222222",
+                name: "bot-2",
+                tenantId: "tenant-2",
+            });
+            await repo.save(p1);
+            await repo.save(p2);
+            const result = await repo.list();
+            expect(result).toHaveLength(2);
+            expect(result.map((p) => p.name).sort()).toEqual(["bot-1", "bot-2"]);
+        });
+        it("returns profiles with env parsed as objects", async () => {
+            const p = makeProfile({ env: { KEY: "value" } });
+            await repo.save(p);
+            const [result] = await repo.list();
+            expect(typeof result.env).toBe("object");
+            expect(result.env).toEqual({ KEY: "value" });
+        });
+    });
+});

package/dist/fleet/capability-conflict.d.ts

@@ -0,0 +1,14 @@
+import type { PluginManifest } from "../api/routes/marketplace-registry.js";
+export interface CapabilityConflict {
+    /** The conflicting capability name (e.g., "tts") */
+    capability: string;
+    /** The plugin ID that already provides this capability */
+    existingPluginId: string;
+    /** The plugin ID being installed that also provides it */
+    newPluginId: string;
+}
+/**
+ * Detect capability conflicts between a new plugin and already-installed plugins.
+ * Returns one conflict entry per overlapping capability (first existing provider wins).
+ */
+export declare function detectCapabilityConflicts(newPluginId: string, installedPluginIds: string[], registry: Pick<PluginManifest, "id" | "capabilities">[]): CapabilityConflict[];

package/dist/fleet/capability-conflict.js

@@ -0,0 +1,29 @@
+/**
+ * Detect capability conflicts between a new plugin and already-installed plugins.
+ * Returns one conflict entry per overlapping capability (first existing provider wins).
+ */
+export function detectCapabilityConflicts(newPluginId, installedPluginIds, registry) {
+    const newEntry = registry.find((p) => p.id === newPluginId);
+    if (!newEntry || newEntry.capabilities.length === 0)
+        return [];
+    // Build map: capability -> first installed pluginId that provides it
+    const installedSet = new Set(installedPluginIds);
+    const capToPlugin = new Map();
+    for (const entry of registry) {
+        if (!installedSet.has(entry.id))
+            continue;
+        for (const cap of entry.capabilities) {
+            if (!capToPlugin.has(cap)) {
+                capToPlugin.set(cap, entry.id);
+            }
+        }
+    }
+    const conflicts = [];
+    for (const cap of newEntry.capabilities) {
+        const existing = capToPlugin.get(cap);
+        if (existing) {
+            conflicts.push({ capability: cap, existingPluginId: existing, newPluginId });
+        }
+    }
+    return conflicts;
+}

package/dist/fleet/capability-conflict.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/fleet/capability-conflict.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from "vitest";
+import { detectCapabilityConflicts } from "./capability-conflict.js";
+const fakeRegistry = [
+    { id: "elevenlabs-tts", capabilities: ["voice", "tts"] },
+    { id: "deepgram-stt", capabilities: ["voice", "stt"] },
+    { id: "discord-channel", capabilities: ["channel"] },
+    { id: "another-tts", capabilities: ["tts", "audio"] },
+];
+describe("detectCapabilityConflicts", () => {
+    it("returns empty array when no conflicts", () => {
+        const conflicts = detectCapabilityConflicts("discord-channel", ["elevenlabs-tts"], fakeRegistry);
+        expect(conflicts).toEqual([]);
+    });
+    it("detects single capability conflict", () => {
+        const conflicts = detectCapabilityConflicts("another-tts", ["elevenlabs-tts"], fakeRegistry);
+        expect(conflicts).toEqual([{ capability: "tts", existingPluginId: "elevenlabs-tts", newPluginId: "another-tts" }]);
+    });
+    it("detects multiple capability conflicts", () => {
+        const conflicts = detectCapabilityConflicts("deepgram-stt", ["elevenlabs-tts"], fakeRegistry);
+        expect(conflicts).toEqual([
+            { capability: "voice", existingPluginId: "elevenlabs-tts", newPluginId: "deepgram-stt" },
+        ]);
+    });
+    it("returns empty when new plugin not in registry", () => {
+        const conflicts = detectCapabilityConflicts("unknown-plugin", ["elevenlabs-tts"], fakeRegistry);
+        expect(conflicts).toEqual([]);
+    });
+    it("returns empty when no plugins installed", () => {
+        const conflicts = detectCapabilityConflicts("elevenlabs-tts", [], fakeRegistry);
+        expect(conflicts).toEqual([]);
+    });
+    it("ignores disabled/uninstalled plugins not in installedIds", () => {
+        const conflicts = detectCapabilityConflicts("another-tts", ["discord-channel"], fakeRegistry);
+        expect(conflicts).toEqual([]);
+    });
+});

package/dist/fleet/capability-env-map.d.ts

@@ -0,0 +1,17 @@
+/** Maps an abstract capability name to the env var and credential vault provider name. */
+export interface CapabilityEnvEntry {
+    /** Env var name injected into bot profile (e.g., "ELEVENLABS_API_KEY") */
+    envKey: string;
+    /** Provider name in the CredentialVaultStore (e.g., "elevenlabs") */
+    vaultProvider: string;
+}
+/**
+ * Static map: capability name -> env injection info.
+ * Source of truth for which env var to inject when a user chooses "hosted".
+ */
+export declare const CAPABILITY_ENV_MAP: Record<string, CapabilityEnvEntry>;
+/**
+ * Look up the env injection info for a capability.
+ * Returns null if the capability is not in the map.
+ */
+export declare function lookupCapabilityEnv(capability: string): CapabilityEnvEntry | null;

package/dist/fleet/capability-env-map.js

@@ -0,0 +1,18 @@
+/**
+ * Static map: capability name -> env injection info.
+ * Source of truth for which env var to inject when a user chooses "hosted".
+ */
+export const CAPABILITY_ENV_MAP = {
+    tts: { envKey: "ELEVENLABS_API_KEY", vaultProvider: "elevenlabs" },
+    stt: { envKey: "DEEPGRAM_API_KEY", vaultProvider: "deepgram" },
+    llm: { envKey: "OPENROUTER_API_KEY", vaultProvider: "openrouter" },
+    "image-gen": { envKey: "REPLICATE_API_TOKEN", vaultProvider: "replicate" },
+    embeddings: { envKey: "OPENROUTER_API_KEY", vaultProvider: "openrouter" },
+};
+/**
+ * Look up the env injection info for a capability.
+ * Returns null if the capability is not in the map.
+ */
+export function lookupCapabilityEnv(capability) {
+    return CAPABILITY_ENV_MAP[capability] ?? null;
+}

package/dist/fleet/capability-env-map.test.d.ts

@@ -0,0 +1 @@
+export {};