@wopr-network/platform-core 1.0.10 → 1.1.0

package/dist/fleet/org-member-repository.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Repository for organization members and invites.
+ *
+ * Follows the mandatory repository pattern: IOrgMemberRepository interface +
+ * DrizzleOrgMemberRepository implementation in the same file.
+ * See: src/fleet/bot-instance-repository.ts
+ */
+import type { DrizzleDb } from "../db/index.js";
+export interface OrgMemberRow {
+    id: string;
+    orgId: string;
+    userId: string;
+    role: "owner" | "admin" | "member";
+    joinedAt: number;
+}
+export interface OrgInviteRow {
+    id: string;
+    orgId: string;
+    email: string;
+    role: "admin" | "member";
+    invitedBy: string;
+    token: string;
+    expiresAt: number;
+    createdAt: number;
+}
+export interface IOrgMemberRepository {
+    listMembers(orgId: string): Promise<OrgMemberRow[]>;
+    addMember(member: OrgMemberRow): Promise<void>;
+    updateMemberRole(orgId: string, userId: string, role: "owner" | "admin" | "member"): Promise<void>;
+    removeMember(orgId: string, userId: string): Promise<void>;
+    findMember(orgId: string, userId: string): Promise<OrgMemberRow | null>;
+    countAdminsAndOwners(orgId: string): Promise<number>;
+    listInvites(orgId: string): Promise<OrgInviteRow[]>;
+    createInvite(invite: OrgInviteRow): Promise<void>;
+    findInviteById(inviteId: string): Promise<OrgInviteRow | null>;
+    findInviteByToken(token: string): Promise<OrgInviteRow | null>;
+    deleteInvite(inviteId: string): Promise<void>;
+    deleteAllMembers(orgId: string): Promise<void>;
+    deleteAllInvites(orgId: string): Promise<void>;
+}
+export declare class DrizzleOrgMemberRepository implements IOrgMemberRepository {
+    private readonly db;
+    constructor(db: DrizzleDb);
+    listMembers(orgId: string): Promise<OrgMemberRow[]>;
+    addMember(member: OrgMemberRow): Promise<void>;
+    updateMemberRole(orgId: string, userId: string, role: "owner" | "admin" | "member"): Promise<void>;
+    removeMember(orgId: string, userId: string): Promise<void>;
+    findMember(orgId: string, userId: string): Promise<OrgMemberRow | null>;
+    countAdminsAndOwners(orgId: string): Promise<number>;
+    listInvites(orgId: string): Promise<OrgInviteRow[]>;
+    createInvite(invite: OrgInviteRow): Promise<void>;
+    findInviteById(inviteId: string): Promise<OrgInviteRow | null>;
+    findInviteByToken(token: string): Promise<OrgInviteRow | null>;
+    deleteInvite(inviteId: string): Promise<void>;
+    deleteAllMembers(orgId: string): Promise<void>;
+    deleteAllInvites(orgId: string): Promise<void>;
+}

package/dist/fleet/org-member-repository.js

@@ -0,0 +1,99 @@
+/**
+ * Repository for organization members and invites.
+ *
+ * Follows the mandatory repository pattern: IOrgMemberRepository interface +
+ * DrizzleOrgMemberRepository implementation in the same file.
+ * See: src/fleet/bot-instance-repository.ts
+ */
+import { and, eq, gt, inArray } from "drizzle-orm";
+import { organizationInvites, organizationMembers } from "../db/schema/organization-members.js";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+function toMember(row) {
+    return {
+        id: row.id,
+        orgId: row.orgId,
+        userId: row.userId,
+        role: row.role,
+        joinedAt: row.joinedAt,
+    };
+}
+function toInvite(row) {
+    return {
+        id: row.id,
+        orgId: row.orgId,
+        email: row.email,
+        role: row.role,
+        invitedBy: row.invitedBy,
+        token: row.token,
+        expiresAt: row.expiresAt,
+        createdAt: row.createdAt,
+    };
+}
+export class DrizzleOrgMemberRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async listMembers(orgId) {
+        const rows = await this.db.select().from(organizationMembers).where(eq(organizationMembers.orgId, orgId));
+        return rows.map(toMember);
+    }
+    async addMember(member) {
+        await this.db.insert(organizationMembers).values(member).onConflictDoNothing();
+    }
+    async updateMemberRole(orgId, userId, role) {
+        await this.db
+            .update(organizationMembers)
+            .set({ role })
+            .where(and(eq(organizationMembers.orgId, orgId), eq(organizationMembers.userId, userId)));
+    }
+    async removeMember(orgId, userId) {
+        await this.db
+            .delete(organizationMembers)
+            .where(and(eq(organizationMembers.orgId, orgId), eq(organizationMembers.userId, userId)));
+    }
+    async findMember(orgId, userId) {
+        const rows = await this.db
+            .select()
+            .from(organizationMembers)
+            .where(and(eq(organizationMembers.orgId, orgId), eq(organizationMembers.userId, userId)));
+        return rows[0] ? toMember(rows[0]) : null;
+    }
+    async countAdminsAndOwners(orgId) {
+        const rows = await this.db
+            .select()
+            .from(organizationMembers)
+            .where(and(eq(organizationMembers.orgId, orgId), inArray(organizationMembers.role, ["admin", "owner"])));
+        return rows.length;
+    }
+    async listInvites(orgId) {
+        const now = Date.now();
+        const rows = await this.db
+            .select()
+            .from(organizationInvites)
+            .where(and(eq(organizationInvites.orgId, orgId), gt(organizationInvites.expiresAt, now)));
+        return rows.map(toInvite);
+    }
+    async createInvite(invite) {
+        await this.db.insert(organizationInvites).values(invite);
+    }
+    async findInviteById(inviteId) {
+        const rows = await this.db.select().from(organizationInvites).where(eq(organizationInvites.id, inviteId));
+        return rows[0] ? toInvite(rows[0]) : null;
+    }
+    async findInviteByToken(token) {
+        const rows = await this.db.select().from(organizationInvites).where(eq(organizationInvites.token, token));
+        return rows[0] ? toInvite(rows[0]) : null;
+    }
+    async deleteInvite(inviteId) {
+        await this.db.delete(organizationInvites).where(eq(organizationInvites.id, inviteId));
+    }
+    async deleteAllMembers(orgId) {
+        await this.db.delete(organizationMembers).where(eq(organizationMembers.orgId, orgId));
+    }
+    async deleteAllInvites(orgId) {
+        await this.db.delete(organizationInvites).where(eq(organizationInvites.orgId, orgId));
+    }
+}

package/dist/fleet/org-member-repository.test.d.ts

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

package/dist/fleet/org-member-repository.test.js

@@ -0,0 +1,215 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleOrgMemberRepository } from "./org-member-repository.js";
+describe("DrizzleOrgMemberRepository", () => {
+    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 DrizzleOrgMemberRepository(db);
+    });
+    // -- Members --
+    describe("addMember + findMember", () => {
+        it("creates a member and retrieves it by orgId + userId", async () => {
+            const member = {
+                id: "m-1",
+                orgId: "org-A",
+                userId: "user-1",
+                role: "member",
+                joinedAt: Date.now(),
+            };
+            await repo.addMember(member);
+            const found = await repo.findMember("org-A", "user-1");
+            expect(found).not.toBeNull();
+            expect(found?.id).toBe("m-1");
+            expect(found?.orgId).toBe("org-A");
+            expect(found?.userId).toBe("user-1");
+            expect(found?.role).toBe("member");
+        });
+        it("returns null when member does not exist", async () => {
+            const found = await repo.findMember("org-A", "nonexistent");
+            expect(found).toBeNull();
+        });
+        it("onConflictDoNothing when adding duplicate org+user", async () => {
+            const member = {
+                id: "m-1",
+                orgId: "org-A",
+                userId: "user-1",
+                role: "member",
+                joinedAt: Date.now(),
+            };
+            await repo.addMember(member);
+            // Add again with different role — should not throw, original preserved
+            await repo.addMember({ ...member, id: "m-2", role: "admin" });
+            const found = await repo.findMember("org-A", "user-1");
+            expect(found?.role).toBe("member"); // original preserved
+        });
+    });
+    describe("listMembers", () => {
+        it("returns all members for the given org", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "member", joinedAt: Date.now() });
+            await repo.addMember({ id: "m-2", orgId: "org-A", userId: "u-2", role: "admin", joinedAt: Date.now() });
+            await repo.addMember({ id: "m-3", orgId: "org-B", userId: "u-3", role: "owner", joinedAt: Date.now() });
+            const members = await repo.listMembers("org-A");
+            expect(members).toHaveLength(2);
+            expect(members.map((m) => m.userId).sort()).toEqual(["u-1", "u-2"]);
+        });
+        it("returns empty array for org with no members", async () => {
+            const members = await repo.listMembers("empty-org");
+            expect(members).toEqual([]);
+        });
+    });
+    describe("updateMemberRole", () => {
+        it("changes the role of an existing member", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "member", joinedAt: Date.now() });
+            await repo.updateMemberRole("org-A", "u-1", "admin");
+            const found = await repo.findMember("org-A", "u-1");
+            expect(found?.role).toBe("admin");
+        });
+    });
+    describe("removeMember", () => {
+        it("removes a member and subsequent find returns null", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "member", joinedAt: Date.now() });
+            await repo.removeMember("org-A", "u-1");
+            const found = await repo.findMember("org-A", "u-1");
+            expect(found).toBeNull();
+        });
+        it("does not throw when removing nonexistent member", async () => {
+            await expect(repo.removeMember("org-A", "no-one")).resolves.toBeUndefined();
+        });
+    });
+    describe("countAdminsAndOwners", () => {
+        it("counts only admin and owner roles", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "member", joinedAt: Date.now() });
+            await repo.addMember({ id: "m-2", orgId: "org-A", userId: "u-2", role: "admin", joinedAt: Date.now() });
+            await repo.addMember({ id: "m-3", orgId: "org-A", userId: "u-3", role: "owner", joinedAt: Date.now() });
+            const count = await repo.countAdminsAndOwners("org-A");
+            expect(count).toBe(2);
+        });
+        it("returns 0 for org with no admins or owners", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "member", joinedAt: Date.now() });
+            expect(await repo.countAdminsAndOwners("org-A")).toBe(0);
+        });
+    });
+    describe("access control boundary", () => {
+        it("member in org A is not found by org B query", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "admin", joinedAt: Date.now() });
+            const found = await repo.findMember("org-B", "u-1");
+            expect(found).toBeNull();
+            const list = await repo.listMembers("org-B");
+            expect(list).toEqual([]);
+        });
+        it("countAdminsAndOwners is scoped to the queried org", async () => {
+            await repo.addMember({ id: "m-1", orgId: "org-A", userId: "u-1", role: "owner", joinedAt: Date.now() });
+            await repo.addMember({ id: "m-2", orgId: "org-B", userId: "u-2", role: "owner", joinedAt: Date.now() });
+            expect(await repo.countAdminsAndOwners("org-A")).toBe(1);
+            expect(await repo.countAdminsAndOwners("org-B")).toBe(1);
+        });
+    });
+    // -- Invites --
+    describe("createInvite + findInviteById", () => {
+        it("creates an invite and retrieves it by ID", async () => {
+            const invite = {
+                id: "inv-1",
+                orgId: "org-A",
+                email: "alice@example.com",
+                role: "member",
+                invitedBy: "u-owner",
+                token: "tok-abc",
+                expiresAt: Date.now() + 86_400_000, // +1 day
+                createdAt: Date.now(),
+            };
+            await repo.createInvite(invite);
+            const found = await repo.findInviteById("inv-1");
+            expect(found).not.toBeNull();
+            expect(found?.email).toBe("alice@example.com");
+            expect(found?.token).toBe("tok-abc");
+        });
+        it("returns null for nonexistent invite", async () => {
+            expect(await repo.findInviteById("no-such")).toBeNull();
+        });
+    });
+    describe("findInviteByToken", () => {
+        it("retrieves invite by token", async () => {
+            await repo.createInvite({
+                id: "inv-1",
+                orgId: "org-A",
+                email: "bob@example.com",
+                role: "admin",
+                invitedBy: "u-owner",
+                token: "tok-xyz",
+                expiresAt: Date.now() + 86_400_000,
+                createdAt: Date.now(),
+            });
+            const found = await repo.findInviteByToken("tok-xyz");
+            expect(found).not.toBeNull();
+            expect(found?.id).toBe("inv-1");
+        });
+        it("returns null for nonexistent token", async () => {
+            expect(await repo.findInviteByToken("bad-token")).toBeNull();
+        });
+    });
+    describe("listInvites", () => {
+        it("returns only non-expired invites for the org", async () => {
+            const now = Date.now();
+            await repo.createInvite({
+                id: "inv-1",
+                orgId: "org-A",
+                email: "a@a.com",
+                role: "member",
+                invitedBy: "u-1",
+                token: "t-1",
+                expiresAt: now + 86_400_000,
+                createdAt: now,
+            });
+            await repo.createInvite({
+                id: "inv-2",
+                orgId: "org-A",
+                email: "b@b.com",
+                role: "member",
+                invitedBy: "u-1",
+                token: "t-2",
+                expiresAt: now - 1000,
+                createdAt: now, // expired
+            });
+            await repo.createInvite({
+                id: "inv-3",
+                orgId: "org-B",
+                email: "c@c.com",
+                role: "member",
+                invitedBy: "u-2",
+                token: "t-3",
+                expiresAt: now + 86_400_000,
+                createdAt: now, // different org
+            });
+            const invites = await repo.listInvites("org-A");
+            expect(invites).toHaveLength(1);
+            expect(invites[0].id).toBe("inv-1");
+        });
+    });
+    describe("deleteInvite", () => {
+        it("removes the invite", async () => {
+            await repo.createInvite({
+                id: "inv-1",
+                orgId: "org-A",
+                email: "a@a.com",
+                role: "member",
+                invitedBy: "u-1",
+                token: "t-1",
+                expiresAt: Date.now() + 86_400_000,
+                createdAt: Date.now(),
+            });
+            await repo.deleteInvite("inv-1");
+            expect(await repo.findInviteById("inv-1")).toBeNull();
+        });
+    });
+});

package/dist/fleet/org-membership-repository.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Repository for org-level tenant membership lookups (BYOK key resolution).
+ *
+ * Follows the mandatory repository pattern: IOrgMembershipRepository interface +
+ * DrizzleOrgMembershipRepository implementation in the same file.
+ * See: src/fleet/bot-instance-repository.ts
+ *
+ * NOTE: This repository queries the `org_memberships` table, which lives in
+ * tenant-keys.db (not platform.db). It is used by org-key resolution to
+ * determine which org tenant's BYOK keys to fall back to.
+ */
+import type { DrizzleDb } from "../db/index.js";
+export interface IOrgMembershipRepository {
+    /** Return the org tenant ID for the given member tenant, or null if not a member. */
+    getOrgTenantIdForMember(memberTenantId: string): Promise<string | null>;
+}
+export declare class DrizzleOrgMembershipRepository implements IOrgMembershipRepository {
+    private readonly db;
+    constructor(db: DrizzleDb);
+    getOrgTenantIdForMember(memberTenantId: string): Promise<string | null>;
+}

package/dist/fleet/org-membership-repository.js

@@ -0,0 +1,29 @@
+/**
+ * Repository for org-level tenant membership lookups (BYOK key resolution).
+ *
+ * Follows the mandatory repository pattern: IOrgMembershipRepository interface +
+ * DrizzleOrgMembershipRepository implementation in the same file.
+ * See: src/fleet/bot-instance-repository.ts
+ *
+ * NOTE: This repository queries the `org_memberships` table, which lives in
+ * tenant-keys.db (not platform.db). It is used by org-key resolution to
+ * determine which org tenant's BYOK keys to fall back to.
+ */
+import { eq } from "drizzle-orm";
+import { orgMemberships } from "../db/schema/org-memberships.js";
+// ---------------------------------------------------------------------------
+// Implementation
+// ---------------------------------------------------------------------------
+export class DrizzleOrgMembershipRepository {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    async getOrgTenantIdForMember(memberTenantId) {
+        const rows = await this.db
+            .select({ orgTenantId: orgMemberships.orgTenantId })
+            .from(orgMemberships)
+            .where(eq(orgMemberships.memberTenantId, memberTenantId));
+        return rows[0]?.orgTenantId ?? null;
+    }
+}

package/dist/fleet/org-membership-repository.test.d.ts

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

package/dist/fleet/org-membership-repository.test.js

@@ -0,0 +1,69 @@
+import { afterAll, beforeAll, beforeEach, describe, expect, it } from "vitest";
+import { orgMemberships } from "../db/schema/org-memberships.js";
+import { beginTestTransaction, createTestDb, endTestTransaction, rollbackTestTransaction } from "../test/db.js";
+import { DrizzleOrgMembershipRepository } from "./org-membership-repository.js";
+describe("DrizzleOrgMembershipRepository", () => {
+    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 DrizzleOrgMembershipRepository(db);
+    });
+    describe("getOrgTenantIdForMember", () => {
+        it("returns the org tenant ID when a membership exists", async () => {
+            await db.insert(orgMemberships).values({
+                orgTenantId: "org-tenant-1",
+                memberTenantId: "member-tenant-1",
+                createdAt: Date.now(),
+            });
+            const result = await repo.getOrgTenantIdForMember("member-tenant-1");
+            expect(result).toBe("org-tenant-1");
+        });
+        it("returns null when no membership exists", async () => {
+            const result = await repo.getOrgTenantIdForMember("nonexistent");
+            expect(result).toBeNull();
+        });
+        it("returns correct org when multiple memberships exist for different members", async () => {
+            await db.insert(orgMemberships).values([
+                { orgTenantId: "org-A", memberTenantId: "member-1", createdAt: Date.now() },
+                { orgTenantId: "org-B", memberTenantId: "member-2", createdAt: Date.now() },
+            ]);
+            expect(await repo.getOrgTenantIdForMember("member-1")).toBe("org-A");
+            expect(await repo.getOrgTenantIdForMember("member-2")).toBe("org-B");
+        });
+        it("access control boundary: member of org A does not resolve to org B", async () => {
+            await db.insert(orgMemberships).values({
+                orgTenantId: "org-A",
+                memberTenantId: "member-1",
+                createdAt: Date.now(),
+            });
+            // member-1 belongs to org-A, not org-B
+            const result = await repo.getOrgTenantIdForMember("member-1");
+            expect(result).toBe("org-A");
+            expect(result).not.toBe("org-B");
+            // member-2 has no membership at all
+            expect(await repo.getOrgTenantIdForMember("member-2")).toBeNull();
+        });
+        it("deletion is reflected in subsequent reads", async () => {
+            await db.insert(orgMemberships).values({
+                orgTenantId: "org-A",
+                memberTenantId: "member-1",
+                createdAt: Date.now(),
+            });
+            expect(await repo.getOrgTenantIdForMember("member-1")).toBe("org-A");
+            // Delete directly via Drizzle (repo has no delete method — it's read-only)
+            const { eq } = await import("drizzle-orm");
+            await db.delete(orgMemberships).where(eq(orgMemberships.memberTenantId, "member-1"));
+            expect(await repo.getOrgTenantIdForMember("member-1")).toBeNull();
+        });
+    });
+});

package/dist/fleet/orphan-cleaner.d.ts

@@ -0,0 +1,28 @@
+import type { IBotInstanceRepository } from "./bot-instance-repository.js";
+import type { INodeCommandBus } from "./node-command-bus.js";
+import type { INodeRepository } from "./node-repository.js";
+export interface OrphanCleanupRequest {
+    nodeId: string;
+    /** Container names currently running on this node (e.g. ["tenant_abc", "tenant_def"]) */
+    runningContainers: string[];
+}
+export interface OrphanCleanupResult {
+    nodeId: string;
+    stopped: string[];
+    kept: string[];
+    errors: Array<{
+        container: string;
+        error: string;
+    }>;
+}
+/**
+ * Stops stale containers on a rebooted node whose bots have been
+ * migrated elsewhere during the outage, then transitions the node to active.
+ */
+export declare class OrphanCleaner {
+    private readonly nodeRepo;
+    private readonly botInstanceRepo;
+    private readonly commandBus;
+    constructor(nodeRepo: INodeRepository, botInstanceRepo: IBotInstanceRepository, commandBus: INodeCommandBus);
+    clean(request: OrphanCleanupRequest): Promise<OrphanCleanupResult>;
+}

package/dist/fleet/orphan-cleaner.js

@@ -0,0 +1,70 @@
+import { logger } from "../config/logger.js";
+/**
+ * Stops stale containers on a rebooted node whose bots have been
+ * migrated elsewhere during the outage, then transitions the node to active.
+ */
+export class OrphanCleaner {
+    nodeRepo;
+    botInstanceRepo;
+    commandBus;
+    constructor(nodeRepo, botInstanceRepo, commandBus) {
+        this.nodeRepo = nodeRepo;
+        this.botInstanceRepo = botInstanceRepo;
+        this.commandBus = commandBus;
+    }
+    async clean(request) {
+        const { nodeId, runningContainers } = request;
+        logger.info(`OrphanCleaner: starting cleanup on node ${nodeId}`, {
+            containerCount: runningContainers.length,
+        });
+        // 1. Get all bot instances assigned to this node
+        const assigned = await this.botInstanceRepo.listByNode(nodeId);
+        const assignedTenantIds = new Set(assigned.map((b) => b.tenantId));
+        const stopped = [];
+        const kept = [];
+        const errors = [];
+        // 2. For each running tenant_* container, check assignment
+        for (const containerName of runningContainers) {
+            if (!containerName.startsWith("tenant_")) {
+                continue; // skip non-tenant containers
+            }
+            const tenantId = containerName.slice("tenant_".length);
+            if (assignedTenantIds.has(tenantId)) {
+                kept.push(containerName);
+                continue;
+            }
+            // Orphan: bot is no longer assigned to this node
+            try {
+                const result = await this.commandBus.send(nodeId, {
+                    type: "bot.stop",
+                    payload: { name: containerName },
+                });
+                if (!result.success) {
+                    const message = result.error ?? "stop command returned success: false";
+                    errors.push({ container: containerName, error: message });
+                    logger.warn(`OrphanCleaner: stop command failed for ${containerName} on ${nodeId}`, {
+                        error: message,
+                    });
+                    continue;
+                }
+                stopped.push(containerName);
+                logger.info(`OrphanCleaner: stopped orphan ${containerName} on ${nodeId}`);
+            }
+            catch (err) {
+                const message = err instanceof Error ? err.message : String(err);
+                errors.push({ container: containerName, error: message });
+                logger.warn(`OrphanCleaner: failed to stop ${containerName} on ${nodeId}`, {
+                    error: message,
+                });
+            }
+        }
+        // 3. Transition node to active via state machine
+        await this.nodeRepo.transition(nodeId, "active", "cleanup_complete", "orphan_cleaner");
+        logger.info(`OrphanCleaner: cleanup complete on node ${nodeId}`, {
+            stopped: stopped.length,
+            kept: kept.length,
+            errors: errors.length,
+        });
+        return { nodeId, stopped, kept, errors };
+    }
+}

package/dist/fleet/orphan-cleaner.test.d.ts

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