@wopr-network/platform-core 1.39.5 → 1.39.6

package/dist/fleet/fleet-manager.d.ts

@@ -53,20 +53,17 @@ export declare class FleetManager {
      */
     getInstance(id: string): Promise<Instance>;
     private buildInstance;
-    /**
-     * Restart: pull new image BEFORE restarting container to avoid downtime on pull failure.
-     * Valid from: running, stopped, exited, dead states.
-     * Throws InvalidStateTransitionError if the container is in an invalid state (e.g. paused).
-     * For remote bots, delegates to the node agent via NodeCommandBus.
-     */
-    restart(id: string): Promise<void>;
     /**
      * Remove a bot: stop container, remove it, optionally remove volumes, delete profile.
      * For remote bots, delegates stop+remove to the node agent via NodeCommandBus.
+     * Container removal is delegated to Instance.remove(); fleet-level cleanup
+     * (profile store, network policy) stays here.
      */
     remove(id: string, removeVolumes?: boolean): Promise<void>;
     /**
      * Get live status of a single bot.
+     * Delegates to Instance.status() which returns a full BotStatus.
+     * Falls back to offline status when no container exists.
      */
     status(id: string): Promise<BotStatus>;
     /**
@@ -78,58 +75,40 @@ export declare class FleetManager {
      */
     listByTenant(tenantId: string): Promise<BotStatus[]>;
     /**
-     * Get container logs.
+     * Get container logs. Delegates to Instance.logs().
      */
     logs(id: string, tail?: number): Promise<string>;
     /**
      * Stream container logs in real-time (follow mode).
-     * Returns a Node.js ReadableStream that emits plain-text log chunks (already demultiplexed).
      * For remote bots, proxies via node-agent bot.logs command and returns a one-shot stream.
-     * Caller is responsible for destroying the stream when done.
+     * For local bots, delegates to Instance.logStream().
      */
     logStream(id: string, opts: {
         since?: string;
         tail?: number;
     }): Promise<NodeJS.ReadableStream>;
-    /** Fields that require container recreation when changed. */
-    private static readonly CONTAINER_FIELDS;
-    /**
-     * Update a bot profile. Only recreates the container if container-relevant
-     * fields changed. Rolls back the profile if container recreation fails.
-     */
-    update(id: string, updates: Partial<Omit<BotProfile, "id">>): Promise<BotProfile>;
     /**
-     * Get disk usage for a bot's /data volume.
-     * Returns null if the container is not running or exec fails.
+     * Get disk usage for a bot's /data volume. Delegates to Instance.getVolumeUsage().
      */
     getVolumeUsage(id: string): Promise<{
         usedBytes: number;
         totalBytes: number;
         availableBytes: number;
     } | null>;
-    /** Get the underlying profile store */
-    get profiles(): IProfileStore;
+    /** Fields that require container recreation when changed. */
+    private static readonly CONTAINER_FIELDS;
     /**
-     * Assert that a container's current state is valid for the requested operation.
-     * Guards against undefined/null Status values from Docker (uses "unknown" as fallback).
-     * Throws InvalidStateTransitionError when the state is not in validStates.
+     * Update a bot profile. Only recreates the container if container-relevant
+     * fields changed. Rolls back the profile if container recreation fails.
      */
-    private assertValidState;
+    update(id: string, updates: Partial<Omit<BotProfile, "id">>): Promise<BotProfile>;
+    /** Get the underlying profile store */
+    get profiles(): IProfileStore;
     private pullImage;
     private createContainer;
     private findContainer;
     private statusForProfile;
-    private buildStatus;
-    private offlineStatus;
-    private getStats;
 }
 export declare class BotNotFoundError extends Error {
     constructor(id: string);
 }
-export declare class InvalidStateTransitionError extends Error {
-    readonly botId: string;
-    readonly operation: string;
-    readonly currentState: string;
-    readonly validStates: string[];
-    constructor(botId: string, operation: string, currentState: string, validStates: string[]);
-}

package/dist/fleet/fleet-manager.js

@@ -106,6 +106,7 @@ export class FleetManager {
                         instanceRepo: this.instanceRepo,
                         proxyManager: this.proxyManager,
                         eventEmitter: this.eventEmitter,
+                        botMetricsTracker: this.botMetricsTracker,
                     });
                     remoteInstance.emitCreated();
                     return remoteInstance;
@@ -173,45 +174,14 @@ export class FleetManager {
             instanceRepo: this.instanceRepo,
             proxyManager: this.proxyManager,
             eventEmitter: this.eventEmitter,
-        });
-    }
-    /**
-     * Restart: pull new image BEFORE restarting container to avoid downtime on pull failure.
-     * Valid from: running, stopped, exited, dead states.
-     * Throws InvalidStateTransitionError if the container is in an invalid state (e.g. paused).
-     * For remote bots, delegates to the node agent via NodeCommandBus.
-     */
-    async restart(id) {
-        return this.withLock(id, async () => {
-            this.botMetricsTracker?.reset(id);
-            const profile = await this.store.get(id);
-            if (!profile)
-                throw new BotNotFoundError(id);
-            const remote = await this.resolveNodeId(id);
-            if (remote) {
-                await remote.commandBus.send(remote.nodeId, {
-                    type: "bot.restart",
-                    payload: { name: profile.name },
-                });
-            }
-            else {
-                // Pull new image first — if this fails, old container is unchanged
-                await this.pullImage(profile.image);
-                const container = await this.findContainer(id);
-                if (!container)
-                    throw new BotNotFoundError(id);
-                const info = await container.inspect();
-                const validRestartStates = new Set(["running", "stopped", "exited", "dead"]);
-                this.assertValidState(id, info.State.Status, "restart", validRestartStates);
-                await container.restart();
-            }
-            logger.info(`Restarted bot ${id}`);
-            this.emitEvent("bot.restarted", id, profile.tenantId);
+            botMetricsTracker: this.botMetricsTracker,
         });
     }
     /**
      * Remove a bot: stop container, remove it, optionally remove volumes, delete profile.
      * For remote bots, delegates stop+remove to the node agent via NodeCommandBus.
+     * Container removal is delegated to Instance.remove(); fleet-level cleanup
+     * (profile store, network policy) stays here.
      */
     async remove(id, removeVolumes = false) {
         return this.withLock(id, async () => {
@@ -226,13 +196,12 @@ export class FleetManager {
                 });
             }
             else {
-                const container = await this.findContainer(id);
-                if (container) {
-                    const info = await container.inspect();
-                    if (info.State.Running) {
-                        await container.stop();
-                    }
-                    await container.remove({ v: removeVolumes });
+                try {
+                    const instance = await this.buildInstance(profile);
+                    await instance.remove(removeVolumes);
+                }
+                catch {
+                    // Container may already be gone — not fatal for fleet-level cleanup
                 }
             }
             // Clean up tenant network if no more containers remain
@@ -240,25 +209,20 @@ export class FleetManager {
                 await this.networkPolicy.cleanupAfterRemoval(profile.tenantId);
             }
             await this.store.delete(id);
-            if (this.proxyManager) {
-                this.proxyManager.removeRoute(id);
-            }
             logger.info(`Removed bot ${id}`);
             this.emitEvent("bot.removed", id, profile.tenantId);
         });
     }
     /**
      * Get live status of a single bot.
+     * Delegates to Instance.status() which returns a full BotStatus.
+     * Falls back to offline status when no container exists.
      */
     async status(id) {
         const profile = await this.store.get(id);
         if (!profile)
             throw new BotNotFoundError(id);
-        const container = await this.findContainer(id);
-        if (!container) {
-            return this.offlineStatus(profile);
-        }
-        return this.buildStatus(profile, container);
+        return this.statusForProfile(profile);
     }
     /**
      * List all bots with live status.
@@ -276,40 +240,16 @@ export class FleetManager {
         return Promise.all(tenantProfiles.map((p) => this.statusForProfile(p)));
     }
     /**
-     * Get container logs.
+     * Get container logs. Delegates to Instance.logs().
      */
     async logs(id, tail = 100) {
-        const container = await this.findContainer(id);
-        if (!container)
-            throw new BotNotFoundError(id);
-        const logBuffer = await container.logs({
-            stdout: true,
-            stderr: true,
-            tail,
-            timestamps: true,
-        });
-        // Docker returns multiplexed binary frames when Tty is false (the default).
-        // Demultiplex by stripping the 8-byte header from each frame so callers
-        // receive plain text instead of binary garbage interleaved with log lines.
-        const buf = Buffer.isBuffer(logBuffer) ? logBuffer : Buffer.from(logBuffer, "binary");
-        const chunks = [];
-        let offset = 0;
-        while (offset + 8 <= buf.length) {
-            const frameSize = buf.readUInt32BE(offset + 4);
-            const end = offset + 8 + frameSize;
-            if (end > buf.length)
-                break;
-            chunks.push(buf.subarray(offset + 8, end));
-            offset = end;
-        }
-        // If demux produced nothing (e.g. TTY container), fall back to raw string
-        return chunks.length > 0 ? Buffer.concat(chunks).toString("utf-8") : buf.toString("utf-8");
+        const instance = await this.getInstance(id);
+        return instance.logs(tail);
     }
     /**
      * Stream container logs in real-time (follow mode).
-     * Returns a Node.js ReadableStream that emits plain-text log chunks (already demultiplexed).
      * For remote bots, proxies via node-agent bot.logs command and returns a one-shot stream.
-     * Caller is responsible for destroying the stream when done.
+     * For local bots, delegates to Instance.logStream().
      */
     async logStream(id, opts) {
         // Check for remote node assignment first (mirrors start/stop/restart pattern)
@@ -327,26 +267,20 @@ export class FleetManager {
             pt.end(logData);
             return pt;
         }
-        const container = await this.findContainer(id);
-        if (!container)
-            throw new BotNotFoundError(id);
-        const logOpts = {
-            stdout: true,
-            stderr: true,
-            follow: true,
-            tail: opts.tail ?? 100,
-            timestamps: true,
-        };
-        if (opts.since) {
-            logOpts.since = opts.since;
+        const instance = await this.getInstance(id);
+        return instance.logStream(opts);
+    }
+    /**
+     * Get disk usage for a bot's /data volume. Delegates to Instance.getVolumeUsage().
+     */
+    async getVolumeUsage(id) {
+        try {
+            const instance = await this.getInstance(id);
+            return instance.getVolumeUsage();
+        }
+        catch {
+            return null;
         }
-        // Docker returns a multiplexed binary stream when Tty is false (the default for
-        // containers created by createContainer without Tty:true). Demultiplex it so
-        // callers receive plain text without 8-byte binary frame headers.
-        const multiplexed = (await container.logs(logOpts));
-        const pt = new PassThrough();
-        this.docker.modem.demuxStream(multiplexed, pt, pt);
-        return pt;
     }
     /** Fields that require container recreation when changed. */
     static CONTAINER_FIELDS = new Set([
@@ -417,72 +351,11 @@ export class FleetManager {
             return updated;
         });
     }
-    /**
-     * Get disk usage for a bot's /data volume.
-     * Returns null if the container is not running or exec fails.
-     */
-    async getVolumeUsage(id) {
-        const container = await this.findContainer(id);
-        if (!container)
-            return null;
-        try {
-            const info = await container.inspect();
-            if (!info.State.Running)
-                return null;
-            const exec = await container.exec({
-                Cmd: ["df", "-B1", "/data"],
-                AttachStdout: true,
-                AttachStderr: false,
-            });
-            const output = await new Promise((resolve, reject) => {
-                exec.start({}, (err, stream) => {
-                    if (err)
-                        return reject(err);
-                    if (!stream)
-                        return reject(new Error("No stream from exec"));
-                    let data = "";
-                    stream.on("data", (chunk) => {
-                        data += chunk.toString();
-                    });
-                    stream.on("end", () => resolve(data));
-                    stream.on("error", reject);
-                });
-            });
-            // Parse df output — second line has the numbers
-            const lines = output.trim().split("\n");
-            if (lines.length < 2)
-                return null;
-            const parts = lines[lines.length - 1].split(/\s+/);
-            if (parts.length < 4)
-                return null;
-            const totalBytes = parseInt(parts[1], 10);
-            const usedBytes = parseInt(parts[2], 10);
-            const availableBytes = parseInt(parts[3], 10);
-            if (Number.isNaN(totalBytes) || Number.isNaN(usedBytes) || Number.isNaN(availableBytes))
-                return null;
-            return { usedBytes, totalBytes, availableBytes };
-        }
-        catch {
-            logger.warn(`Failed to get volume usage for bot ${id}`);
-            return null;
-        }
-    }
     /** Get the underlying profile store */
     get profiles() {
         return this.store;
     }
     // --- Private helpers ---
-    /**
-     * Assert that a container's current state is valid for the requested operation.
-     * Guards against undefined/null Status values from Docker (uses "unknown" as fallback).
-     * Throws InvalidStateTransitionError when the state is not in validStates.
-     */
-    assertValidState(id, rawStatus, operation, validStates) {
-        const currentState = typeof rawStatus === "string" && rawStatus ? rawStatus : "unknown";
-        if (!validStates.has(currentState)) {
-            throw new InvalidStateTransitionError(id, operation, currentState, [...validStates]);
-        }
-    }
     async pullImage(image) {
         logger.info(`Pulling image ${image}`);
         // Build authconfig from environment variables if present.
@@ -589,71 +462,29 @@ export class FleetManager {
         return this.docker.getContainer(containers[0].Id);
     }
     async statusForProfile(profile) {
-        const container = await this.findContainer(profile.id);
-        if (!container)
-            return this.offlineStatus(profile);
-        return this.buildStatus(profile, container);
-    }
-    async buildStatus(profile, container) {
-        const info = await container.inspect();
-        let stats = null;
-        if (info.State.Running) {
-            try {
-                stats = await this.getStats(container);
-            }
-            catch {
-                // stats not available
-            }
+        try {
+            const instance = await this.buildInstance(profile);
+            return instance.status();
+        }
+        catch {
+            // Container not found — return offline status
+            const now = new Date().toISOString();
+            return {
+                id: profile.id,
+                name: profile.name,
+                description: profile.description,
+                image: profile.image,
+                containerId: null,
+                state: "stopped",
+                health: null,
+                uptime: null,
+                startedAt: null,
+                createdAt: now,
+                updatedAt: now,
+                stats: null,
+                applicationMetrics: null,
+            };
         }
-        const now = new Date().toISOString();
-        return {
-            id: profile.id,
-            name: profile.name,
-            description: profile.description,
-            image: profile.image,
-            containerId: info.Id,
-            state: info.State.Status,
-            health: info.State.Health?.Status ?? null,
-            uptime: info.State.Running && info.State.StartedAt ? info.State.StartedAt : null,
-            startedAt: info.State.StartedAt || null,
-            createdAt: info.Created || now,
-            updatedAt: now,
-            stats,
-            applicationMetrics: this.botMetricsTracker?.getMetrics(profile.id) ?? null,
-        };
-    }
-    offlineStatus(profile) {
-        const now = new Date().toISOString();
-        return {
-            id: profile.id,
-            name: profile.name,
-            description: profile.description,
-            image: profile.image,
-            containerId: null,
-            state: "stopped",
-            health: null,
-            uptime: null,
-            startedAt: null,
-            createdAt: now,
-            updatedAt: now,
-            stats: null,
-            applicationMetrics: null,
-        };
-    }
-    async getStats(container) {
-        const raw = await container.stats({ stream: false });
-        const cpuDelta = raw.cpu_stats.cpu_usage.total_usage - raw.precpu_stats.cpu_usage.total_usage;
-        const systemDelta = raw.cpu_stats.system_cpu_usage - raw.precpu_stats.system_cpu_usage;
-        const numCpus = raw.cpu_stats.online_cpus || 1;
-        const cpuPercent = systemDelta > 0 ? (cpuDelta / systemDelta) * numCpus * 100 : 0;
-        const memUsage = raw.memory_stats.usage || 0;
-        const memLimit = raw.memory_stats.limit || 1;
-        return {
-            cpuPercent: Math.round(cpuPercent * 100) / 100,
-            memoryUsageMb: Math.round(memUsage / 1024 / 1024),
-            memoryLimitMb: Math.round(memLimit / 1024 / 1024),
-            memoryPercent: Math.round((memUsage / memLimit) * 100 * 100) / 100,
-        };
     }
 }
 export class BotNotFoundError extends Error {
@@ -662,18 +493,3 @@ export class BotNotFoundError extends Error {
         this.name = "BotNotFoundError";
     }
 }
-export class InvalidStateTransitionError extends Error {
-    botId;
-    operation;
-    currentState;
-    validStates;
-    constructor(botId, operation, currentState, validStates) {
-        super(`Cannot ${operation} bot ${botId}: container is in state "${currentState}". ` +
-            `Valid states for ${operation}: ${validStates.join(", ")}.`);
-        this.name = "InvalidStateTransitionError";
-        this.botId = botId;
-        this.operation = operation;
-        this.currentState = currentState;
-        this.validStates = validStates;
-    }
-}

package/dist/fleet/fleet-manager.test.js

@@ -126,74 +126,21 @@ describe("FleetManager", () => {
             expect(container.stop).toHaveBeenCalled();
         });
     });
-    describe("restart", () => {
-        it("pulls image before restarting a running container", async () => {
-            // Store the profile first; default mockContainer has state "running" — valid for restart
-            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
-            docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
-            await fleet.restart("bot-id");
-            // Pull is called first
-            expect(docker.pull).toHaveBeenCalledWith(PROFILE_PARAMS.image, {});
-            // Then restart
-            expect(container.restart).toHaveBeenCalled();
-        });
-        it("restarts a container in exited state (crash recovery)", async () => {
-            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
-            container.inspect.mockResolvedValue({
-                Id: "container-123",
-                Created: "2026-01-01T00:00:00Z",
-                State: { Status: "exited", Running: false, StartedAt: "", Health: null },
-            });
-            docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
-            await fleet.restart("bot-id");
-            expect(container.restart).toHaveBeenCalled();
-        });
-        it("restarts a container in stopped state", async () => {
-            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
-            container.inspect.mockResolvedValue({
-                Id: "container-123",
-                Created: "2026-01-01T00:00:00Z",
-                State: { Status: "stopped", Running: false, StartedAt: "", Health: null },
-            });
-            docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
-            await fleet.restart("bot-id");
-            expect(container.restart).toHaveBeenCalled();
-        });
-        it("restarts a container in dead state (crash recovery)", async () => {
-            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
-            container.inspect.mockResolvedValue({
-                Id: "container-123",
-                Created: "2026-01-01T00:00:00Z",
-                State: { Status: "dead", Running: false, StartedAt: "", Health: null },
-            });
-            docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
-            await fleet.restart("bot-id");
-            expect(container.restart).toHaveBeenCalled();
-        });
-        it("does not restart if pull fails", async () => {
-            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
-            docker.modem.followProgress.mockImplementation((_stream, cb) => cb(new Error("Pull failed")));
-            await expect(fleet.restart("bot-id")).rejects.toThrow("Pull failed");
-            expect(container.restart).not.toHaveBeenCalled();
-        });
-        it("throws BotNotFoundError for missing profile", async () => {
-            await expect(fleet.restart("missing")).rejects.toThrow(BotNotFoundError);
-        });
-    });
+    // restart tests moved to instance.test.ts — Instance.restart() + Instance.pullImage()
     describe("remove", () => {
         it("stops running container, removes it, and deletes profile", async () => {
             await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             await fleet.remove("bot-id");
             expect(container.stop).toHaveBeenCalled();
-            expect(container.remove).toHaveBeenCalledWith({ v: false });
+            expect(container.remove).toHaveBeenCalledWith({ force: true, v: false });
             expect(store.delete).toHaveBeenCalledWith("bot-id");
         });
         it("removes volumes when requested", async () => {
             await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             await fleet.remove("bot-id", true);
-            expect(container.remove).toHaveBeenCalledWith({ v: true });
+            expect(container.remove).toHaveBeenCalledWith({ force: true, v: true });
         });
         it("deletes profile even when no container exists", async () => {
             await store.save({ id: "bot-id", ...PROFILE_PARAMS });
@@ -240,13 +187,13 @@ describe("FleetManager", () => {
     });
     describe("logs", () => {
         it("returns container logs", async () => {
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             const logs = await fleet.logs("bot-id", 50);
             expect(container.logs).toHaveBeenCalledWith(expect.objectContaining({ tail: 50, stdout: true, stderr: true }));
             expect(logs).toContain("log line 1");
         });
-        it("throws BotNotFoundError when container not found", async () => {
-            docker.listContainers.mockResolvedValue([]);
+        it("throws BotNotFoundError when profile not found", async () => {
             await expect(fleet.logs("missing")).rejects.toThrow(BotNotFoundError);
         });
     });
@@ -255,6 +202,7 @@ describe("FleetManager", () => {
             const { PassThrough } = await import("node:stream");
             const mockStream = new PassThrough();
             container.logs.mockResolvedValue(mockStream);
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             const stream = await fleet.logStream("bot-id", { since: "2026-01-01T00:00:00Z", tail: 50 });
             // Result is a PassThrough (demuxed), not the raw multiplexed stream
@@ -276,6 +224,7 @@ describe("FleetManager", () => {
             const { PassThrough } = await import("node:stream");
             const mockStream = new PassThrough();
             container.logs.mockResolvedValue(mockStream);
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             await fleet.logStream("bot-id", {});
             expect(container.logs).toHaveBeenCalledWith({
@@ -287,8 +236,7 @@ describe("FleetManager", () => {
             });
             mockStream.destroy();
         });
-        it("throws BotNotFoundError when container not found", async () => {
-            docker.listContainers.mockResolvedValue([]);
+        it("throws BotNotFoundError when profile not found", async () => {
             await expect(fleet.logStream("missing", {})).rejects.toThrow(BotNotFoundError);
         });
         it("proxies via node-agent for remote bots", async () => {
@@ -557,31 +505,7 @@ describe("FleetManager", () => {
             expect(bus.send).not.toHaveBeenCalled();
             expect(docker.pull).toHaveBeenCalled();
         });
-        it("should dispatch restart via commandBus when bot has nodeId", async () => {
-            const container = mockContainer();
-            const docker = mockDocker(container);
-            const store = mockStore();
-            const bus = mockCommandBus();
-            const instanceRepo = mockInstanceRepo();
-            const botId = "bot-restart-1";
-            await instanceRepo.create({ id: botId, tenantId: "t1", name: "restart-bot", nodeId: "node-3" });
-            const fleet = new FleetManager(docker, store, undefined, undefined, undefined, bus, instanceRepo);
-            await store.save({
-                id: botId,
-                tenantId: "t1",
-                name: "restart-bot",
-                description: "",
-                image: "ghcr.io/wopr-network/wopr:latest",
-                env: {},
-                restartPolicy: "unless-stopped",
-            });
-            await fleet.restart(botId);
-            expect(bus.send).toHaveBeenCalledWith("node-3", {
-                type: "bot.restart",
-                payload: { name: "restart-bot" },
-            });
-            expect(container.restart).not.toHaveBeenCalled();
-        });
+        // remote restart test removed — restart moved to Instance
         it("should dispatch remove via commandBus when bot has nodeId", async () => {
             const container = mockContainer();
             const docker = mockDocker(container);
@@ -645,6 +569,7 @@ describe("FleetManager", () => {
             const containerWithExec = mockContainer({
                 exec: vi.fn().mockResolvedValue(execMock),
             });
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             docker.getContainer.mockReturnValue(containerWithExec);
             const result = await fleet.getVolumeUsage("bot-id");
@@ -655,6 +580,7 @@ describe("FleetManager", () => {
             });
         });
         it("returns null when container is not found", async () => {
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([]);
             const result = await fleet.getVolumeUsage("bot-id");
             expect(result).toBeNull();
@@ -666,6 +592,7 @@ describe("FleetManager", () => {
                     State: { Running: false },
                 }),
             });
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             docker.getContainer.mockReturnValue(stoppedContainer);
             const result = await fleet.getVolumeUsage("bot-id");
@@ -675,6 +602,7 @@ describe("FleetManager", () => {
             const containerWithFailingExec = mockContainer({
                 exec: vi.fn().mockRejectedValue(new Error("exec failed")),
             });
+            await store.save({ id: "bot-id", ...PROFILE_PARAMS });
             docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
             docker.getContainer.mockReturnValue(containerWithFailingExec);
             const result = await fleet.getVolumeUsage("bot-id");