@wopr-network/platform-core 1.39.4 → 1.39.6

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");

package/dist/fleet/instance.d.ts

@@ -1,8 +1,9 @@
 import type Docker from "dockerode";
+import type { BotMetricsTracker } from "../gateway/bot-metrics-tracker.js";
 import type { ProxyManagerInterface } from "../proxy/types.js";
 import type { IBotInstanceRepository } from "./bot-instance-repository.js";
 import type { FleetEventEmitter } from "./fleet-event-emitter.js";
-import type { BotProfile } from "./types.js";
+import type { BotProfile, BotStatus } from "./types.js";
 /**
  * Instance — a runtime handle to a container.
  *
@@ -22,6 +23,7 @@ export interface InstanceDeps {
     instanceRepo?: IBotInstanceRepository;
     proxyManager?: ProxyManagerInterface;
     eventEmitter?: FleetEventEmitter;
+    botMetricsTracker?: BotMetricsTracker;
 }
 export declare class Instance {
     readonly id: string;
@@ -33,13 +35,64 @@ export declare class Instance {
     private readonly instanceRepo;
     private readonly proxyManager;
     private readonly eventEmitter;
+    private readonly botMetricsTracker;
+    /** Simple per-instance mutex to serialize start/stop/restart/remove. */
+    private lockPromise;
     constructor(deps: InstanceDeps);
+    /**
+     * Remote instances have containerId like "remote:node-3".
+     * Local Docker operations are not supported — callers (e.g. wopr-platform)
+     * handle remote delegation at a higher level via NodeCommandBus.
+     */
+    private get isRemote();
+    private assertLocal;
+    private withLock;
     /** Emit bot.created — call only from FleetManager.create(), not getInstance() */
     emitCreated(): void;
     start(): Promise<void>;
     stop(): Promise<void>;
-    remove(): Promise<void>;
-    status(): Promise<"running" | "stopped" | "gone">;
+    /**
+     * Restart the container.
+     * Callers that need an image update should call pullImage() first.
+     */
+    restart(): Promise<void>;
+    /**
+     * Pull the latest version of this instance's image.
+     * Call before restart() to update the image before restarting.
+     */
+    pullImage(): Promise<void>;
+    remove(removeVolumes?: boolean): Promise<void>;
+    /**
+     * Simple container state check (running / stopped / gone).
+     */
+    containerState(): Promise<"running" | "stopped" | "gone">;
+    /**
+     * Full status including profile data, container state, resource stats,
+     * and application metrics. Returns BotStatus.
+     */
+    status(): Promise<BotStatus>;
+    /**
+     * Get container logs (demultiplexed to plain text).
+     */
+    logs(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).
+     * Caller is responsible for destroying the stream when done.
+     */
+    logStream(opts: {
+        since?: string;
+        tail?: number;
+    }): Promise<NodeJS.ReadableStream>;
+    /**
+     * Get disk usage for this instance's /data volume.
+     * Returns null if the container is not running or exec fails.
+     */
+    getVolumeUsage(): Promise<{
+        usedBytes: number;
+        totalBytes: number;
+        availableBytes: number;
+    } | null>;
     /**
      * Register this instance in the billing system.
      * Skip for ephemeral instances — they bill per-token, not per-instance.
@@ -50,5 +103,7 @@ export declare class Instance {
      * Skip for ephemeral instances — they're accessed directly via Docker DNS.
      */
     setupProxy(): Promise<void>;
+    private offlineStatus;
+    private getStats;
     private emit;
 }

package/dist/fleet/instance.js

@@ -1,3 +1,4 @@
+import { PassThrough } from "node:stream";
 import { logger } from "../config/logger.js";
 export class Instance {
     id;
@@ -9,6 +10,9 @@ export class Instance {
     instanceRepo;
     proxyManager;
     eventEmitter;
+    botMetricsTracker;
+    /** Simple per-instance mutex to serialize start/stop/restart/remove. */
+    lockPromise = Promise.resolve();
     constructor(deps) {
         this.id = deps.profile.id;
         this.containerId = deps.containerId;
@@ -19,55 +23,139 @@ export class Instance {
         this.instanceRepo = deps.instanceRepo;
         this.proxyManager = deps.proxyManager;
         this.eventEmitter = deps.eventEmitter;
+        this.botMetricsTracker = deps.botMetricsTracker;
+    }
+    /**
+     * Remote instances have containerId like "remote:node-3".
+     * Local Docker operations are not supported — callers (e.g. wopr-platform)
+     * handle remote delegation at a higher level via NodeCommandBus.
+     */
+    get isRemote() {
+        return this.containerId.startsWith("remote:");
+    }
+    assertLocal(operation) {
+        if (this.isRemote) {
+            throw new Error(`${operation} is not supported on remote instances — use node agent`);
+        }
+    }
+    async withLock(fn) {
+        const prev = this.lockPromise;
+        let resolve;
+        this.lockPromise = new Promise((r) => {
+            resolve = r;
+        });
+        try {
+            await prev;
+            return await fn();
+        }
+        finally {
+            resolve();
+        }
     }
     /** Emit bot.created — call only from FleetManager.create(), not getInstance() */
     emitCreated() {
         this.emit("bot.created");
     }
     async start() {
-        const container = this.docker.getContainer(this.containerId);
-        await container.start();
-        logger.info(`Instance started`, { id: this.id, containerName: this.containerName, url: this.url });
-        this.emit("bot.started");
+        this.assertLocal("start()");
+        return this.withLock(async () => {
+            const container = this.docker.getContainer(this.containerId);
+            await container.start();
+            logger.info(`Instance started`, { id: this.id, containerName: this.containerName, url: this.url });
+            this.emit("bot.started");
+        });
     }
     async stop() {
-        const container = this.docker.getContainer(this.containerId);
-        try {
-            await container.stop({ t: 10 });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (!msg.includes("not running") && !msg.includes("already stopped")) {
-                throw err;
+        this.assertLocal("stop()");
+        return this.withLock(async () => {
+            const container = this.docker.getContainer(this.containerId);
+            try {
+                await container.stop({ t: 10 });
             }
-        }
-        logger.info(`Instance stopped`, { id: this.id, containerName: this.containerName });
-        this.emit("bot.stopped");
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                if (!msg.includes("not running") && !msg.includes("already stopped")) {
+                    throw err;
+                }
+            }
+            logger.info(`Instance stopped`, { id: this.id, containerName: this.containerName });
+            this.emit("bot.stopped");
+        });
     }
-    async remove() {
-        const container = this.docker.getContainer(this.containerId);
-        try {
-            await container.stop({ t: 5 }).catch(() => { });
-            await container.remove({ force: true });
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            if (!msg.includes("No such container")) {
-                throw err;
+    /**
+     * Restart the container.
+     * Callers that need an image update should call pullImage() first.
+     */
+    async restart() {
+        this.assertLocal("restart()");
+        return this.withLock(async () => {
+            this.botMetricsTracker?.reset(this.id);
+            const container = this.docker.getContainer(this.containerId);
+            const info = await container.inspect();
+            const validStates = new Set(["running", "stopped", "exited", "dead"]);
+            const currentState = typeof info.State.Status === "string" && info.State.Status ? info.State.Status : "unknown";
+            if (!validStates.has(currentState)) {
+                throw new Error(`Cannot restart instance ${this.id}: container is in state "${currentState}". ` +
+                    `Valid states: ${[...validStates].join(", ")}.`);
             }
-        }
-        if (this.proxyManager) {
+            await container.restart();
+            logger.info(`Instance restarted`, { id: this.id, containerName: this.containerName });
+            this.emit("bot.restarted");
+        });
+    }
+    /**
+     * Pull the latest version of this instance's image.
+     * Call before restart() to update the image before restarting.
+     */
+    async pullImage() {
+        this.assertLocal("pullImage()");
+        logger.info(`Pulling image ${this.profile.image}`, { id: this.id });
+        const username = process.env.REGISTRY_USERNAME;
+        const password = process.env.REGISTRY_PASSWORD;
+        const server = process.env.REGISTRY_SERVER;
+        const authconfig = username && password ? { username, password, serveraddress: server ?? "ghcr.io" } : undefined;
+        const stream = await this.docker.pull(this.profile.image, authconfig ? { authconfig } : {});
+        await new Promise((resolve, reject) => {
+            this.docker.modem.followProgress(stream, (err) => {
+                if (err)
+                    reject(err);
+                else
+                    resolve();
+            });
+        });
+        logger.info(`Image pulled`, { id: this.id, image: this.profile.image });
+    }
+    async remove(removeVolumes = false) {
+        this.assertLocal("remove()");
+        return this.withLock(async () => {
+            const container = this.docker.getContainer(this.containerId);
             try {
-                await this.proxyManager.removeRoute(this.id);
+                await container.stop({ t: 5 }).catch(() => { });
+                await container.remove({ force: true, v: removeVolumes });
             }
             catch (err) {
-                logger.warn("Proxy route cleanup failed (non-fatal)", { id: this.id, err });
+                const msg = err instanceof Error ? err.message : String(err);
+                if (!msg.includes("No such container")) {
+                    throw err;
+                }
             }
-        }
-        logger.info(`Instance removed`, { id: this.id, containerName: this.containerName });
-        this.emit("bot.removed");
+            if (this.proxyManager) {
+                try {
+                    await this.proxyManager.removeRoute(this.id);
+                }
+                catch (err) {
+                    logger.warn("Proxy route cleanup failed (non-fatal)", { id: this.id, err });
+                }
+            }
+            logger.info(`Instance removed`, { id: this.id, containerName: this.containerName });
+            this.emit("bot.removed");
+        });
     }
-    async status() {
+    /**
+     * Simple container state check (running / stopped / gone).
+     */
+    async containerState() {
+        this.assertLocal("containerState()");
         try {
             const container = this.docker.getContainer(this.containerId);
             const info = await container.inspect();
@@ -77,6 +165,149 @@ export class Instance {
             return "gone";
         }
     }
+    /**
+     * Full status including profile data, container state, resource stats,
+     * and application metrics. Returns BotStatus.
+     */
+    async status() {
+        this.assertLocal("status()");
+        try {
+            const container = this.docker.getContainer(this.containerId);
+            const info = await container.inspect();
+            let stats = null;
+            if (info.State.Running) {
+                try {
+                    stats = await this.getStats(container);
+                }
+                catch {
+                    // stats not available
+                }
+            }
+            const now = new Date().toISOString();
+            return {
+                id: this.profile.id,
+                name: this.profile.name,
+                description: this.profile.description,
+                image: this.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(this.profile.id) ?? null,
+            };
+        }
+        catch {
+            return this.offlineStatus();
+        }
+    }
+    /**
+     * Get container logs (demultiplexed to plain text).
+     */
+    async logs(tail = 100) {
+        this.assertLocal("logs()");
+        const container = this.docker.getContainer(this.containerId);
+        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");
+    }
+    /**
+     * Stream container logs in real-time (follow mode).
+     * Returns a Node.js ReadableStream that emits plain-text log chunks (already demultiplexed).
+     * Caller is responsible for destroying the stream when done.
+     */
+    async logStream(opts) {
+        this.assertLocal("logStream()");
+        const container = this.docker.getContainer(this.containerId);
+        const logOpts = {
+            stdout: true,
+            stderr: true,
+            follow: true,
+            tail: opts.tail ?? 100,
+            timestamps: true,
+        };
+        if (opts.since) {
+            logOpts.since = opts.since;
+        }
+        // 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;
+    }
+    /**
+     * Get disk usage for this instance's /data volume.
+     * Returns null if the container is not running or exec fails.
+     */
+    async getVolumeUsage() {
+        this.assertLocal("getVolumeUsage()");
+        try {
+            const container = this.docker.getContainer(this.containerId);
+            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 instance ${this.id}`);
+            return null;
+        }
+    }
     /**
      * Register this instance in the billing system.
      * Skip for ephemeral instances — they bill per-token, not per-instance.
@@ -123,6 +354,39 @@ export class Instance {
             logger.warn("Proxy route registration failed (non-fatal)", { id: this.id, err });
         }
     }
+    offlineStatus() {
+        const now = new Date().toISOString();
+        return {
+            id: this.profile.id,
+            name: this.profile.name,
+            description: this.profile.description,
+            image: this.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,
+        };
+    }
     emit(type) {
         if (this.eventEmitter) {
             this.eventEmitter.emit({

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

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