@wopr-network/platform-core 1.39.4 → 1.39.6

package/src/credits/ledger.ts

@@ -372,19 +372,25 @@ export class DrizzleLedger implements ILedger {
     }
 
     // Verify balance before hitting DB
-    let totalDebit = 0;
-    let totalCredit = 0;
+    let totalDebit = 0n;
+    let totalCredit = 0n;
     for (const line of input.lines) {
       if (line.amount.isZero() || line.amount.isNegative()) {
         throw new Error("Journal line amounts must be positive");
       }
-      if (line.side === "debit") totalDebit += line.amount.toRaw();
-      else totalCredit += line.amount.toRaw();
+      if (line.side === "debit") totalDebit += BigInt(line.amount.toRaw());
+      else totalCredit += BigInt(line.amount.toRaw());
     }
     if (totalDebit !== totalCredit) {
-      throw new Error(
-        `Unbalanced entry: debits=${Credit.fromRaw(totalDebit).toDisplayString()}, credits=${Credit.fromRaw(totalCredit).toDisplayString()}`,
-      );
+      const fmtDebit =
+        totalDebit <= BigInt(Number.MAX_SAFE_INTEGER)
+          ? Credit.fromRaw(Number(totalDebit)).toDisplayString()
+          : `${totalDebit} raw`;
+      const fmtCredit =
+        totalCredit <= BigInt(Number.MAX_SAFE_INTEGER)
+          ? Credit.fromRaw(Number(totalCredit)).toDisplayString()
+          : `${totalCredit} raw`;
+      throw new Error(`Unbalanced entry: debits=${fmtDebit}, credits=${fmtCredit}`);
     }
 
     return this.db.transaction(async (tx) => {

package/src/db/schema/ledger.ts

@@ -70,6 +70,9 @@ export const journalLines = pgTable(
     accountId: text("account_id")
       .notNull()
       .references(() => accounts.id),
+    // mode: "number" truncates values > Number.MAX_SAFE_INTEGER (≈$9.007M in nanodollars).
+    // Credit.fromRaw() guards against this with a RangeError.
+    // If balances approach $9M, migrate to mode: "bigint" (returns string from Drizzle).
     amount: bigint("amount", { mode: "number" }).notNull(), // nanodollars, always positive
     side: entrySideEnum("side").notNull(),
   },
@@ -89,6 +92,9 @@ export const accountBalances = pgTable("account_balances", {
   accountId: text("account_id")
     .primaryKey()
     .references(() => accounts.id),
+  // mode: "number" truncates values > Number.MAX_SAFE_INTEGER (≈$9.007M in nanodollars).
+  // Credit.fromRaw() guards against this with a RangeError.
+  // If balances approach $9M, migrate to mode: "bigint" (returns string from Drizzle).
   balance: bigint("balance", { mode: "number" }).notNull().default(0), // net balance in nanodollars
   lastUpdated: text("last_updated").notNull().default(sql`(now())`),
 });

package/src/fleet/fleet-manager.test.ts

@@ -157,73 +157,7 @@ describe("FleetManager", () => {
     });
   });
 
-  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: unknown, cb: (err: Error | null) => void) =>
-        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 () => {
@@ -233,7 +167,7 @@ describe("FleetManager", () => {
       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");
     });
 
@@ -243,7 +177,7 @@ describe("FleetManager", () => {
 
       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 () => {
@@ -304,6 +238,7 @@ 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);
@@ -312,8 +247,7 @@ describe("FleetManager", () => {
       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);
     });
   });
@@ -323,6 +257,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 });
@@ -346,6 +281,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", {});
@@ -359,8 +295,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);
     });
 
@@ -718,44 +653,7 @@ describe("FleetManager", () => {
       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 as unknown as 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",
-      } as BotProfile);
-
-      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();
@@ -850,6 +748,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);
 
@@ -863,6 +762,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();
@@ -875,6 +775,7 @@ describe("FleetManager", () => {
           State: { Running: false },
         }),
       });
+      await store.save({ id: "bot-id", ...PROFILE_PARAMS });
       docker.listContainers.mockResolvedValue([{ Id: "container-123" }]);
       docker.getContainer.mockReturnValue(stoppedContainer);
 
@@ -886,6 +787,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);
 

package/src/fleet/fleet-manager.ts

@@ -14,7 +14,7 @@ import { Instance } from "./instance.js";
 import type { INodeCommandBus } from "./node-command-bus.js";
 import type { IProfileStore } from "./profile-store.js";
 import { getSharedVolumeConfig } from "./shared-volume-config.js";
-import type { BotProfile, BotStatus, ContainerStats } from "./types.js";
+import type { BotProfile, BotStatus } from "./types.js";
 
 const CONTAINER_LABEL = "wopr.managed";
 const CONTAINER_ID_LABEL = "wopr.bot-id";
@@ -134,6 +134,7 @@ export class FleetManager {
             instanceRepo: this.instanceRepo,
             proxyManager: this.proxyManager,
             eventEmitter: this.eventEmitter,
+            botMetricsTracker: this.botMetricsTracker,
           });
           remoteInstance.emitCreated();
           return remoteInstance;
@@ -203,46 +204,15 @@ 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: string): Promise<void> {
-    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: string, removeVolumes = false): Promise<void> {
     return this.withLock(id, async () => {
@@ -256,13 +226,11 @@ export class FleetManager {
           payload: { name: profile.name, removeVolumes },
         });
       } 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
         }
       }
 
@@ -272,9 +240,6 @@ export class FleetManager {
       }
 
       await this.store.delete(id);
-      if (this.proxyManager) {
-        this.proxyManager.removeRoute(id);
-      }
       logger.info(`Removed bot ${id}`);
       this.emitEvent("bot.removed", id, profile.tenantId);
     });
@@ -282,17 +247,13 @@ export class FleetManager {
 
   /**
    * 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: string): Promise<BotStatus> {
     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);
   }
 
   /**
@@ -313,41 +274,17 @@ export class FleetManager {
   }
 
   /**
-   * Get container logs.
+   * Get container logs. Delegates to Instance.logs().
    */
   async logs(id: string, tail = 100): Promise<string> {
-    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 as unknown as string, "binary");
-    const chunks: Buffer[] = [];
-    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: string, opts: { since?: string; tail?: number }): Promise<NodeJS.ReadableStream> {
     // Check for remote node assignment first (mirrors start/stop/restart pattern)
@@ -365,31 +302,20 @@ export class FleetManager {
       return pt;
     }
 
-    const container = await this.findContainer(id);
-    if (!container) throw new BotNotFoundError(id);
+    const instance = await this.getInstance(id);
+    return instance.logStream(opts);
+  }
 
-    const logOpts: Record<string, unknown> = {
-      stdout: true,
-      stderr: true,
-      follow: true,
-      tail: opts.tail ?? 100,
-      timestamps: true,
-    };
-    if (opts.since) {
-      logOpts.since = opts.since;
+  /**
+   * Get disk usage for a bot's /data volume. Delegates to Instance.getVolumeUsage().
+   */
+  async getVolumeUsage(id: string): Promise<{ usedBytes: number; totalBytes: number; availableBytes: number } | null> {
+    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)) as unknown as NodeJS.ReadableStream;
-    const pt = new PassThrough();
-    (
-      this.docker.modem as unknown as {
-        demuxStream(stream: NodeJS.ReadableStream, stdout: PassThrough, stderr: PassThrough): void;
-      }
-    ).demuxStream(multiplexed, pt, pt);
-    return pt;
   }
 
   /** Fields that require container recreation when changed. */
@@ -465,57 +391,6 @@ export class FleetManager {
     });
   }
 
-  /**
-   * Get disk usage for a bot's /data volume.
-   * Returns null if the container is not running or exec fails.
-   */
-  async getVolumeUsage(id: string): Promise<{ usedBytes: number; totalBytes: number; availableBytes: number } | null> {
-    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<string>((resolve, reject) => {
-        exec.start({}, (err: Error | null, stream: import("node:stream").Duplex | undefined) => {
-          if (err) return reject(err);
-          if (!stream) return reject(new Error("No stream from exec"));
-          let data = "";
-          stream.on("data", (chunk: Buffer) => {
-            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(): IProfileStore {
     return this.store;
@@ -523,18 +398,6 @@ export class FleetManager {
 
   // --- 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.
-   */
-  private assertValidState(id: string, rawStatus: unknown, operation: string, validStates: Set<string>): void {
-    const currentState = typeof rawStatus === "string" && rawStatus ? rawStatus : "unknown";
-    if (!validStates.has(currentState)) {
-      throw new InvalidStateTransitionError(id, operation, currentState, [...validStates]);
-    }
-  }
-
   private async pullImage(image: string): Promise<void> {
     logger.info(`Pulling image ${image}`);
 
@@ -655,77 +518,28 @@ export class FleetManager {
   }
 
   private async statusForProfile(profile: BotProfile): Promise<BotStatus> {
-    const container = await this.findContainer(profile.id);
-    if (!container) return this.offlineStatus(profile);
-    return this.buildStatus(profile, container);
-  }
-
-  private async buildStatus(profile: BotProfile, container: Docker.Container): Promise<BotStatus> {
-    const info = await container.inspect();
-
-    let stats: ContainerStats | null = 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 as BotStatus["state"],
-      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,
-    };
-  }
-
-  private offlineStatus(profile: BotProfile): BotStatus {
-    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,
-    };
-  }
-
-  private async getStats(container: Docker.Container): Promise<ContainerStats> {
-    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,
-    };
   }
 }
 
@@ -735,22 +549,3 @@ export class BotNotFoundError extends Error {
     this.name = "BotNotFoundError";
   }
 }
-
-export 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[]) {
-    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;
-  }
-}