@wopr-network/platform-core 1.0.10 → 1.1.0

package/dist/fleet/orphan-cleaner.test.js

@@ -0,0 +1,120 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { OrphanCleaner } from "./orphan-cleaner.js";
+const NODE_ID = "node-1";
+function makeNodeRepo(overrides = {}) {
+    return {
+        getById: vi.fn().mockReturnValue(null),
+        getBySecret: vi.fn().mockReturnValue(null),
+        list: vi.fn().mockReturnValue([]),
+        register: vi.fn(),
+        registerSelfHosted: vi.fn(),
+        transition: vi.fn(),
+        updateHeartbeat: vi.fn(),
+        addCapacity: vi.fn(),
+        findBestTarget: vi.fn().mockReturnValue(null),
+        listTransitions: vi.fn().mockReturnValue([]),
+        ...overrides,
+    };
+}
+function makeBotInstanceRepo(instances = []) {
+    return {
+        getById: vi.fn().mockReturnValue(null),
+        listByNode: vi.fn().mockReturnValue(instances),
+        listByTenant: vi.fn().mockReturnValue([]),
+        create: vi.fn(),
+        reassign: vi.fn(),
+        setBillingState: vi.fn(),
+    };
+}
+function makeCommandBus(sendResult = { id: "cmd-1", type: "command_result", command: "bot.stop", success: true }) {
+    return {
+        send: vi.fn().mockResolvedValue(sendResult),
+    };
+}
+describe("OrphanCleaner.clean", () => {
+    let nodeRepo;
+    let commandBus;
+    beforeEach(() => {
+        nodeRepo = makeNodeRepo();
+        commandBus = makeCommandBus();
+        vi.clearAllMocks();
+    });
+    it("stops containers assigned to a different node", async () => {
+        const botInstanceRepo = makeBotInstanceRepo([{ tenantId: "keep-me", nodeId: NODE_ID }]);
+        const send = vi.fn().mockResolvedValue({ id: "cmd-1", type: "command_result", command: "bot.stop", success: true });
+        commandBus = { send };
+        const cleaner = new OrphanCleaner(nodeRepo, botInstanceRepo, commandBus);
+        const result = await cleaner.clean({
+            nodeId: NODE_ID,
+            runningContainers: ["tenant_orphan", "tenant_keep-me"],
+        });
+        // tenant_orphan is NOT in the db result for this node -> orphan -> should be stopped
+        expect(send).toHaveBeenCalledWith(NODE_ID, {
+            type: "bot.stop",
+            payload: { name: "tenant_orphan" },
+        });
+        expect(result.stopped).toContain("tenant_orphan");
+        // tenant_keep-me IS assigned to this node -> should NOT be stopped
+        expect(result.kept).toContain("tenant_keep-me");
+    });
+    it("does NOT stop containers still assigned to this node", async () => {
+        const botInstanceRepo = makeBotInstanceRepo([{ tenantId: "mine", nodeId: NODE_ID }]);
+        const send = vi.fn().mockResolvedValue({ id: "cmd-1", type: "command_result", command: "bot.stop", success: true });
+        commandBus = { send };
+        const cleaner = new OrphanCleaner(nodeRepo, botInstanceRepo, commandBus);
+        const result = await cleaner.clean({
+            nodeId: NODE_ID,
+            runningContainers: ["tenant_mine"],
+        });
+        // Should NOT have sent any stop command
+        expect(send).not.toHaveBeenCalled();
+        expect(result.stopped).toHaveLength(0);
+        expect(result.kept).toContain("tenant_mine");
+    });
+    it("transitions node to active after cleanup even if nothing to stop", async () => {
+        const botInstanceRepo = makeBotInstanceRepo([]);
+        const cleaner = new OrphanCleaner(nodeRepo, botInstanceRepo, commandBus);
+        const result = await cleaner.clean({
+            nodeId: NODE_ID,
+            runningContainers: [],
+        });
+        // Should have called transition to "active"
+        expect(nodeRepo.transition).toHaveBeenCalledWith(NODE_ID, "active", "cleanup_complete", "orphan_cleaner");
+        expect(result.nodeId).toBe(NODE_ID);
+        expect(result.stopped).toHaveLength(0);
+        expect(result.kept).toHaveLength(0);
+        expect(result.errors).toHaveLength(0);
+    });
+    it("pushes to errors and not stopped when send returns success: false", async () => {
+        const botInstanceRepo = makeBotInstanceRepo([{ tenantId: "keep-me", nodeId: NODE_ID }]);
+        const send = vi.fn().mockResolvedValue({
+            id: "cmd-1",
+            type: "command_result",
+            command: "bot.stop",
+            success: false,
+            error: "container not found",
+        });
+        commandBus = { send };
+        const cleaner = new OrphanCleaner(nodeRepo, botInstanceRepo, commandBus);
+        const result = await cleaner.clean({
+            nodeId: NODE_ID,
+            runningContainers: ["tenant_orphan"],
+        });
+        expect(send).toHaveBeenCalledWith(NODE_ID, {
+            type: "bot.stop",
+            payload: { name: "tenant_orphan" },
+        });
+        expect(result.stopped).toHaveLength(0);
+        expect(result.errors).toHaveLength(1);
+        expect(result.errors[0]).toMatchObject({
+            container: "tenant_orphan",
+            error: "container not found",
+        });
+    });
+    it("transitions node to active regardless of stop failures", async () => {
+        const botInstanceRepo = makeBotInstanceRepo([]);
+        const cleaner = new OrphanCleaner(nodeRepo, botInstanceRepo, commandBus);
+        await cleaner.clean({ nodeId: NODE_ID, runningContainers: [] });
+        expect(nodeRepo.transition).toHaveBeenCalledWith(NODE_ID, "active", "cleanup_complete", "orphan_cleaner");
+    });
+});

package/dist/fleet/page-context-repository.d.ts

@@ -0,0 +1,20 @@
+import type { DrizzleDb } from "../db/index.js";
+export interface PageContext {
+    userId: string;
+    currentPage: string;
+    pagePrompt: string | null;
+    updatedAt: number;
+}
+export interface IPageContextRepository {
+    get(userId: string): Promise<PageContext | null>;
+    set(userId: string, currentPage: string, pagePrompt: string | null): Promise<void>;
+    list(): Promise<PageContext[]>;
+}
+export declare class DrizzlePageContextRepository implements IPageContextRepository {
+    private readonly db;
+    constructor(db: DrizzleDb);
+    get(userId: string): Promise<PageContext | null>;
+    set(userId: string, currentPage: string, pagePrompt: string | null): Promise<void>;
+    list(): Promise<PageContext[]>;
+    private toPageContext;
+}

package/dist/fleet/page-context-repository.js

@@ -0,0 +1,33 @@
+import { eq } from "drizzle-orm";
+import { pageContexts } from "../db/schema/index.js";
+export class DrizzlePageContextRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async get(userId) {
+        const rows = await this.db.select().from(pageContexts).where(eq(pageContexts.userId, userId));
+        return rows[0] ? this.toPageContext(rows[0]) : null;
+    }
+    async set(userId, currentPage, pagePrompt) {
+        await this.db
+            .insert(pageContexts)
+            .values({ userId, currentPage, pagePrompt, updatedAt: Date.now() })
+            .onConflictDoUpdate({
+            target: pageContexts.userId,
+            set: { currentPage, pagePrompt, updatedAt: Date.now() },
+        });
+    }
+    async list() {
+        const rows = await this.db.select().from(pageContexts);
+        return rows.map((r) => this.toPageContext(r));
+    }
+    toPageContext(row) {
+        return {
+            userId: row.userId,
+            currentPage: row.currentPage,
+            pagePrompt: row.pagePrompt,
+            updatedAt: row.updatedAt,
+        };
+    }
+}

package/dist/fleet/placement.d.ts

@@ -0,0 +1,26 @@
+export interface NodeInput {
+    id: string;
+    host: string;
+    status: string;
+    capacityMb: number;
+    usedMb: number;
+}
+export interface PlacementResult {
+    nodeId: string;
+    host: string;
+    availableMb: number;
+}
+/**
+ * Pure bin-packing placement: find the active node with the MOST free capacity.
+ * Operates on an in-memory node list — no DB access.
+ *
+ * @param nodes - In-memory list of nodes to search
+ * @param requiredMb - Memory the new bot needs (default: 100 MB)
+ * @returns The best node, or null if no node has capacity
+ */
+export declare function findPlacement(nodes: NodeInput[], requiredMb?: number): PlacementResult | null;
+/**
+ * Pure variant: find placement excluding specific node(s).
+ * Used during migration to avoid placing back on source node.
+ */
+export declare function findPlacementExcluding(nodes: NodeInput[], excludeNodeIds: string[], requiredMb?: number): PlacementResult | null;

package/dist/fleet/placement.js

@@ -0,0 +1,30 @@
+/**
+ * Pure bin-packing placement: find the active node with the MOST free capacity.
+ * Operates on an in-memory node list — no DB access.
+ *
+ * @param nodes - In-memory list of nodes to search
+ * @param requiredMb - Memory the new bot needs (default: 100 MB)
+ * @returns The best node, or null if no node has capacity
+ */
+export function findPlacement(nodes, requiredMb = 100) {
+    const best = nodes
+        .filter((n) => n.status === "active" && n.capacityMb - n.usedMb >= requiredMb)
+        .sort((a, b) => b.capacityMb - b.usedMb - (a.capacityMb - a.usedMb))[0];
+    if (!best)
+        return null;
+    return {
+        nodeId: best.id,
+        host: best.host,
+        availableMb: best.capacityMb - best.usedMb,
+    };
+}
+/**
+ * Pure variant: find placement excluding specific node(s).
+ * Used during migration to avoid placing back on source node.
+ */
+export function findPlacementExcluding(nodes, excludeNodeIds, requiredMb = 100) {
+    if (excludeNodeIds.length === 0)
+        return findPlacement(nodes, requiredMb);
+    const excludeSet = new Set(excludeNodeIds);
+    return findPlacement(nodes.filter((n) => !excludeSet.has(n.id)), requiredMb);
+}

package/dist/fleet/placement.test.d.ts

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

package/dist/fleet/placement.test.js

@@ -0,0 +1,129 @@
+import { describe, expect, it } from "vitest";
+import { findPlacement, findPlacementExcluding } from "./placement.js";
+function node(overrides) {
+    return {
+        host: "10.0.0.1",
+        status: "active",
+        capacityMb: 1000,
+        usedMb: 0,
+        ...overrides,
+    };
+}
+describe("findPlacement", () => {
+    it("returns the node with most free capacity", () => {
+        const nodes = [
+            node({ id: "node-1", capacityMb: 1000, usedMb: 800 }), // 200 free
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 2000, usedMb: 500 }), // 1500 free (winner)
+            node({ id: "node-3", host: "10.0.0.3", capacityMb: 1000, usedMb: 950 }), // 50 free (not enough)
+        ];
+        const result = findPlacement(nodes, 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-2");
+        expect(result?.availableMb).toBe(1500);
+    });
+    it("returns the host for the winning node", () => {
+        const nodes = [node({ id: "node-1", host: "10.0.0.1", capacityMb: 1000, usedMb: 0 })];
+        const result = findPlacement(nodes, 100);
+        expect(result).not.toBeNull();
+        expect(result?.host).toBe("10.0.0.1");
+    });
+    it("returns null when no node has capacity", () => {
+        const nodes = [node({ id: "node-1", capacityMb: 1000, usedMb: 950 })];
+        const result = findPlacement(nodes, 100);
+        expect(result).toBeNull();
+    });
+    it("returns null when nodes array is empty", () => {
+        const result = findPlacement([], 100);
+        expect(result).toBeNull();
+    });
+    it("skips non-active draining nodes", () => {
+        const nodes = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0, status: "draining" }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 1000, usedMb: 0 }),
+        ];
+        const result = findPlacement(nodes, 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-2");
+    });
+    it("skips offline and unhealthy and recovering nodes", () => {
+        const nodes = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0, status: "offline" }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 2000, usedMb: 0, status: "unhealthy" }),
+            node({ id: "node-3", host: "10.0.0.3", capacityMb: 2000, usedMb: 0, status: "recovering" }),
+        ];
+        const result = findPlacement(nodes, 100);
+        expect(result).toBeNull();
+    });
+    it("skips returning nodes", () => {
+        const nodeList = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0, status: "returning" }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 1000, usedMb: 0, status: "active" }),
+        ];
+        const result = findPlacement(nodeList, 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-2");
+    });
+    it("uses 100 MB as default requiredMb", () => {
+        const nodes = [node({ id: "node-1", capacityMb: 1000, usedMb: 900 })];
+        const result = findPlacement(nodes);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-1");
+        expect(result?.availableMb).toBe(100);
+    });
+    it("returns null when free capacity is exactly below required", () => {
+        const nodes = [node({ id: "node-1", capacityMb: 1000, usedMb: 901 })];
+        const result = findPlacement(nodes);
+        expect(result).toBeNull();
+    });
+});
+describe("findPlacementExcluding", () => {
+    it("excludes specified node IDs", () => {
+        const nodes = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0 }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 1000, usedMb: 0 }),
+        ];
+        const result = findPlacementExcluding(nodes, ["node-1"], 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-2");
+    });
+    it("returns null when all nodes excluded", () => {
+        const nodes = [node({ id: "node-1", capacityMb: 2000, usedMb: 0 })];
+        const result = findPlacementExcluding(nodes, ["node-1"], 100);
+        expect(result).toBeNull();
+    });
+    it("excludes multiple node IDs", () => {
+        const nodes = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0 }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 1500, usedMb: 0 }),
+            node({ id: "node-3", host: "10.0.0.3", capacityMb: 1000, usedMb: 0 }),
+        ];
+        const result = findPlacementExcluding(nodes, ["node-1", "node-2"], 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-3");
+    });
+    it("delegates to findPlacement when excludeNodeIds is empty", () => {
+        const nodes = [node({ id: "node-1", capacityMb: 2000, usedMb: 0 })];
+        const result = findPlacementExcluding(nodes, [], 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-1");
+    });
+    it("skips returning nodes", () => {
+        const nodeList = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0, status: "returning" }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 1000, usedMb: 0, status: "active" }),
+        ];
+        const result = findPlacementExcluding(nodeList, ["node-3"], 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-2");
+    });
+    it("still picks most free capacity among non-excluded nodes", () => {
+        const nodes = [
+            node({ id: "node-1", capacityMb: 2000, usedMb: 0 }),
+            node({ id: "node-2", host: "10.0.0.2", capacityMb: 1500, usedMb: 0 }),
+            node({ id: "node-3", host: "10.0.0.3", capacityMb: 800, usedMb: 0 }),
+        ];
+        const result = findPlacementExcluding(nodes, ["node-1"], 100);
+        expect(result).not.toBeNull();
+        expect(result?.nodeId).toBe("node-2");
+    });
+});

package/dist/fleet/pool-config.test.d.ts

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

package/dist/fleet/pool-config.test.js

@@ -0,0 +1,57 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Capture constructor args for each test
+const constructorCalls = [];
+vi.mock("pg", () => {
+    class MockPool {
+        constructor(opts) {
+            constructorCalls.push(opts);
+        }
+        query = vi.fn();
+        end = vi.fn();
+    }
+    return { Pool: MockPool };
+});
+describe("getPool config", () => {
+    beforeEach(() => {
+        vi.stubEnv("DATABASE_URL", "postgresql://test:test@localhost:5432/test");
+        constructorCalls.length = 0;
+        vi.resetModules();
+    });
+    afterEach(() => {
+        vi.unstubAllEnvs();
+    });
+    it("uses default pool config when no DB_POOL_* env vars are set", async () => {
+        const { getPool } = await import("./services.js");
+        getPool();
+        expect(constructorCalls[0]).toEqual({
+            connectionString: "postgresql://test:test@localhost:5432/test",
+            max: 20,
+            idleTimeoutMillis: 30_000,
+            connectionTimeoutMillis: 5_000,
+        });
+    });
+    it("respects DB_POOL_MAX env var", async () => {
+        vi.stubEnv("DB_POOL_MAX", "50");
+        const { getPool } = await import("./services.js");
+        getPool();
+        expect(constructorCalls[0]).toMatchObject({ max: 50 });
+    });
+    it("respects DB_POOL_IDLE_TIMEOUT_MS env var", async () => {
+        vi.stubEnv("DB_POOL_IDLE_TIMEOUT_MS", "60000");
+        const { getPool } = await import("./services.js");
+        getPool();
+        expect(constructorCalls[0]).toMatchObject({ idleTimeoutMillis: 60_000 });
+    });
+    it("respects DB_POOL_CONNECTION_TIMEOUT_MS env var", async () => {
+        vi.stubEnv("DB_POOL_CONNECTION_TIMEOUT_MS", "10000");
+        const { getPool } = await import("./services.js");
+        getPool();
+        expect(constructorCalls[0]).toMatchObject({ connectionTimeoutMillis: 10_000 });
+    });
+    it("falls back to defaults for non-numeric env values", async () => {
+        vi.stubEnv("DB_POOL_MAX", "not-a-number");
+        const { getPool } = await import("./services.js");
+        getPool();
+        expect(constructorCalls[0]).toMatchObject({ max: 20 });
+    });
+});

package/dist/fleet/profile-loader.d.ts

@@ -0,0 +1,7 @@
+import { type ProfileTemplate } from "./profile-schema.js";
+/** Load and validate a single YAML profile template */
+export declare function parseProfileTemplate(content: string, filename: string): ProfileTemplate;
+/** Load all profile templates from a directory */
+export declare function loadProfileTemplates(templatesDir: string): ProfileTemplate[];
+/** Resolve the default templates directory (relative to project root) */
+export declare function defaultTemplatesDir(): string;

package/dist/fleet/profile-loader.js

@@ -0,0 +1,36 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseYaml } from "yaml";
+import { profileTemplateSchema } from "./profile-schema.js";
+/** Load and validate a single YAML profile template */
+export function parseProfileTemplate(content, filename) {
+    const raw = parseYaml(content);
+    const result = profileTemplateSchema.safeParse(raw);
+    if (!result.success) {
+        throw new Error(`Invalid profile template "${filename}": ${result.error.message}`);
+    }
+    return result.data;
+}
+/** Load all profile templates from a directory */
+export function loadProfileTemplates(templatesDir) {
+    if (!fs.existsSync(templatesDir)) {
+        return [];
+    }
+    const files = fs.readdirSync(templatesDir).filter((f) => f.endsWith(".yaml") || f.endsWith(".yml"));
+    const templates = [];
+    for (const file of files) {
+        const content = fs.readFileSync(path.join(templatesDir, file), "utf-8");
+        templates.push(parseProfileTemplate(content, file));
+    }
+    return templates;
+}
+/** Resolve the default templates directory (relative to project root) */
+export function defaultTemplatesDir() {
+    if (process.env.FLEET_TEMPLATES_DIR) {
+        return path.resolve(process.env.FLEET_TEMPLATES_DIR);
+    }
+    // In production, templates are bundled alongside the dist output.
+    // The repo layout puts them at <root>/templates/.
+    // __dirname at runtime is dist/fleet/, so we go up two levels.
+    return path.resolve(import.meta.dirname, "..", "..", "templates");
+}

package/dist/fleet/profile-loader.test.d.ts

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

package/dist/fleet/profile-loader.test.js

@@ -0,0 +1,109 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { loadProfileTemplates, parseProfileTemplate } from "./profile-loader.js";
+describe("parseProfileTemplate", () => {
+    it("parses valid YAML into a ProfileTemplate", () => {
+        const yaml = `
+name: test-bot
+description: A test bot
+channel:
+  plugin: test-channel
+  config:
+    TOKEN: abc
+provider:
+  plugin: test-provider
+  config:
+    KEY: xyz
+release: canary
+image: "ghcr.io/wopr-network/test:canary"
+`;
+        const result = parseProfileTemplate(yaml, "test.yaml");
+        expect(result.name).toBe("test-bot");
+        expect(result.release).toBe("canary");
+        expect(result.channel.plugin).toBe("test-channel");
+        expect(result.provider.config.KEY).toBe("xyz");
+    });
+    it("throws on invalid YAML content", () => {
+        const yaml = `
+name: test-bot
+release: invalid-channel
+`;
+        expect(() => parseProfileTemplate(yaml, "bad.yaml")).toThrow('Invalid profile template "bad.yaml"');
+    });
+});
+describe("loadProfileTemplates", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "wopr-templates-"));
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    const validYaml = `
+name: test-bot
+description: A test bot
+channel:
+  plugin: test-channel
+provider:
+  plugin: test-provider
+release: stable
+image: "ghcr.io/wopr-network/test:stable"
+`;
+    it("loads all .yaml files from directory", () => {
+        fs.writeFileSync(path.join(tmpDir, "bot1.yaml"), validYaml);
+        fs.writeFileSync(path.join(tmpDir, "bot2.yml"), validYaml.replace("test-bot", "bot-two"));
+        const templates = loadProfileTemplates(tmpDir);
+        expect(templates).toHaveLength(2);
+    });
+    it("ignores non-YAML files", () => {
+        fs.writeFileSync(path.join(tmpDir, "bot.yaml"), validYaml);
+        fs.writeFileSync(path.join(tmpDir, "readme.txt"), "not yaml");
+        const templates = loadProfileTemplates(tmpDir);
+        expect(templates).toHaveLength(1);
+    });
+    it("returns empty array for non-existent directory", () => {
+        const templates = loadProfileTemplates("/tmp/does-not-exist-wopr-test");
+        expect(templates).toEqual([]);
+    });
+    it("returns empty array for empty directory", () => {
+        const templates = loadProfileTemplates(tmpDir);
+        expect(templates).toEqual([]);
+    });
+    it("throws on invalid template file", () => {
+        fs.writeFileSync(path.join(tmpDir, "bad.yaml"), "name: x\nrelease: nope\n");
+        expect(() => loadProfileTemplates(tmpDir)).toThrow("Invalid profile template");
+    });
+});
+import { defaultTemplatesDir } from "./profile-loader.js";
+describe("defaultTemplatesDir", () => {
+    it("returns FLEET_TEMPLATES_DIR env var when set", () => {
+        const orig = process.env.FLEET_TEMPLATES_DIR;
+        try {
+            process.env.FLEET_TEMPLATES_DIR = "/custom/templates";
+            const dir = defaultTemplatesDir();
+            expect(dir).toBe("/custom/templates");
+        }
+        finally {
+            if (orig === undefined) {
+                delete process.env.FLEET_TEMPLATES_DIR;
+            }
+            else {
+                process.env.FLEET_TEMPLATES_DIR = orig;
+            }
+        }
+    });
+    it("returns a path containing 'templates' when env var is not set", () => {
+        const orig = process.env.FLEET_TEMPLATES_DIR;
+        try {
+            delete process.env.FLEET_TEMPLATES_DIR;
+            const dir = defaultTemplatesDir();
+            expect(dir).toContain("templates");
+        }
+        finally {
+            if (orig !== undefined)
+                process.env.FLEET_TEMPLATES_DIR = orig;
+        }
+    });
+});

package/dist/fleet/profile-schema.d.ts

@@ -0,0 +1,73 @@
+import { z } from "zod";
+/** Release channels for bot deployments */
+export declare const releaseChannelSchema: z.ZodEnum<{
+    stable: "stable";
+    canary: "canary";
+    staging: "staging";
+}>;
+export type ReleaseChannel = z.infer<typeof releaseChannelSchema>;
+/** Restart policy for bot containers */
+export declare const restartPolicySchema: z.ZodEnum<{
+    "unless-stopped": "unless-stopped";
+    always: "always";
+    no: "no";
+    "on-failure": "on-failure";
+}>;
+export type RestartPolicy = z.infer<typeof restartPolicySchema>;
+/** Health check configuration */
+export declare const healthCheckSchema: z.ZodObject<{
+    endpoint: z.ZodDefault<z.ZodString>;
+    intervalSeconds: z.ZodDefault<z.ZodNumber>;
+    timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+    retries: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type HealthCheck = z.infer<typeof healthCheckSchema>;
+/** Volume mount configuration */
+export declare const volumeMountSchema: z.ZodObject<{
+    host: z.ZodString;
+    container: z.ZodString;
+    readonly: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type VolumeMount = z.infer<typeof volumeMountSchema>;
+/** Bot profile template schema — validated when loading YAML templates */
+export declare const profileTemplateSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    channel: z.ZodObject<{
+        plugin: z.ZodString;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+    provider: z.ZodObject<{
+        plugin: z.ZodString;
+        config: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    }, z.core.$strip>;
+    release: z.ZodEnum<{
+        stable: "stable";
+        canary: "canary";
+        staging: "staging";
+    }>;
+    image: z.ZodString;
+    restartPolicy: z.ZodDefault<z.ZodEnum<{
+        "unless-stopped": "unless-stopped";
+        always: "always";
+        no: "no";
+        "on-failure": "on-failure";
+    }>>;
+    healthCheck: z.ZodDefault<z.ZodObject<{
+        endpoint: z.ZodDefault<z.ZodString>;
+        intervalSeconds: z.ZodDefault<z.ZodNumber>;
+        timeoutSeconds: z.ZodDefault<z.ZodNumber>;
+        retries: z.ZodDefault<z.ZodNumber>;
+    }, z.core.$strip>>;
+    volumes: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        host: z.ZodString;
+        container: z.ZodString;
+        readonly: z.ZodDefault<z.ZodBoolean>;
+    }, z.core.$strip>>>;
+    env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    discovery: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        topics: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type ProfileTemplate = z.infer<typeof profileTemplateSchema>;