@wopr-network/platform-core 1.39.4 → 1.39.6

package/dist/credits/credit-expiry-cron.test.js

@@ -81,6 +81,36 @@ describe("runCreditExpiryCron", () => {
         const balanceAfterSecond = await ledger.balance("tenant-1");
         expect(balanceAfterSecond.toCents()).toBe(balanceAfterFirst.toCents());
     });
+    it("skips expiry when balance has been fully consumed before cron runs", async () => {
+        // Simulate: grant expires but tenant spent everything before cron ran
+        await ledger.credit("tenant-1", Credit.fromCents(500), "promo", {
+            description: "Promo",
+            referenceId: "promo:fully-consumed",
+            expiresAt: "2026-01-10T00:00:00Z",
+        });
+        // Tenant spends entire balance before expiry cron runs
+        await ledger.debit("tenant-1", Credit.fromCents(500), "bot_runtime", { description: "Full spend" });
+        const result = await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
+        // Zero balance — nothing to expire
+        expect(result.processed).toBe(0);
+        const balance = await ledger.balance("tenant-1");
+        expect(balance.toCents()).toBe(0);
+    });
+    it("only expires remaining balance when usage reduced it between grant and expiry", async () => {
+        // Grant $5, spend $3 before cron, cron should only expire remaining $2
+        await ledger.credit("tenant-1", Credit.fromCents(500), "promo", {
+            description: "Promo",
+            referenceId: "promo:partial-concurrent",
+            expiresAt: "2026-01-10T00:00:00Z",
+        });
+        await ledger.debit("tenant-1", Credit.fromCents(300), "bot_runtime", { description: "Partial spend" });
+        const result = await runCreditExpiryCron({ ledger, now: "2026-01-15T00:00:00Z" });
+        expect(result.processed).toBe(1);
+        expect(result.expired).toContain("tenant-1");
+        // $5 granted - $3 used - $2 expired = $0
+        const balance = await ledger.balance("tenant-1");
+        expect(balance.toCents()).toBe(0);
+    });
     it("does not return unknown entry type even with expiresAt metadata", async () => {
         // Simulate a hypothetical new entry type that has expiresAt in metadata.
         // With the old denylist approach, this would be incorrectly returned.

package/dist/credits/ledger.js

@@ -169,19 +169,25 @@ export class DrizzleLedger {
             throw new Error("Journal entry must have at least 2 lines");
         }
         // 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();
+                totalDebit += BigInt(line.amount.toRaw());
             else
-                totalCredit += line.amount.toRaw();
+                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) => {
             const entryId = crypto.randomUUID();

package/dist/credits/ledger.test.js

@@ -38,6 +38,21 @@ describe("DrizzleLedger", () => {
                 ],
             })).rejects.toThrow("Unbalanced");
         });
+        it("throws Unbalanced entry (not RangeError) when BigInt totals exceed MAX_SAFE_INTEGER", async () => {
+            // Two debit lines each at MAX_SAFE_INTEGER raw — their BigInt sum exceeds MAX_SAFE_INTEGER.
+            // Before the fix, Credit.fromRaw(Number(totalDebit)) would throw RangeError, masking the real error.
+            const big = Credit.fromRaw(Number.MAX_SAFE_INTEGER);
+            const small = Credit.fromRaw(1);
+            await expect(ledger.post({
+                entryType: "purchase",
+                tenantId: "t1",
+                lines: [
+                    { accountCode: "1000", amount: big, side: "debit" },
+                    { accountCode: "1000", amount: big, side: "debit" },
+                    { accountCode: "2000:t1", amount: small, side: "credit" },
+                ],
+            })).rejects.toThrow("Unbalanced entry");
+        });
         it("rejects zero-amount lines", async () => {
             await expect(ledger.post({
                 entryType: "purchase",
@@ -209,6 +224,22 @@ describe("DrizzleLedger", () => {
         it("rejects zero amount", async () => {
             await expect(ledger.debit("t1", Credit.ZERO, "bot_runtime")).rejects.toThrow("must be positive");
         });
+        it("concurrent debits do not overdraft", async () => {
+            // Balance is $10.00 from beforeEach credit.
+            // Two concurrent $8 debits — only one should succeed.
+            const results = await Promise.allSettled([
+                ledger.debit("t1", Credit.fromCents(800), "bot_runtime"),
+                ledger.debit("t1", Credit.fromCents(800), "bot_runtime"),
+            ]);
+            const successes = results.filter((r) => r.status === "fulfilled");
+            const failures = results.filter((r) => r.status === "rejected");
+            expect(successes).toHaveLength(1);
+            expect(failures).toHaveLength(1);
+            expect(failures[0].reason).toBeInstanceOf(InsufficientBalanceError);
+            // Balance should be $2.00, not -$6.00
+            const bal = await ledger.balance("t1");
+            expect(bal.toCentsRounded()).toBe(200);
+        });
     });
     // -----------------------------------------------------------------------
     // balance()
@@ -268,6 +299,20 @@ describe("DrizzleLedger", () => {
             expect(tb.balanced).toBe(true);
             expect(tb.totalDebits.equals(tb.totalCredits)).toBe(true);
         });
+        it("detects imbalance from direct DB corruption", async () => {
+            await ledger.credit("t1", Credit.fromCents(100), "purchase");
+            // Corrupt the ledger: insert an unmatched debit line directly into journal_lines.
+            const entryRows = await pool.query("SELECT id FROM journal_entries LIMIT 1");
+            const accountRows = await pool.query("SELECT id FROM accounts WHERE code = '1000' LIMIT 1");
+            const entryId = entryRows.rows[0].id;
+            const accountId = accountRows.rows[0].id;
+            // Insert an unmatched debit line worth 999 raw units — no corresponding credit
+            await pool.query(`INSERT INTO journal_lines (id, journal_entry_id, account_id, amount, side)
+         VALUES ('corrupt-line-1', $1, $2, 999, 'debit')`, [entryId, accountId]);
+            const tb = await ledger.trialBalance();
+            expect(tb.balanced).toBe(false);
+            expect(tb.difference.toRaw()).toBe(999);
+        });
     });
     // -----------------------------------------------------------------------
     // history()
@@ -491,4 +536,46 @@ describe("DrizzleLedger", () => {
             expect(tb.balanced).toBe(true);
         });
     });
+    // -----------------------------------------------------------------------
+    // deadlock prevention — concurrent multi-line entries
+    // -----------------------------------------------------------------------
+    describe("deadlock prevention", () => {
+        it("concurrent multi-line entries with overlapping accounts succeed", async () => {
+            // Fund two tenants
+            await ledger.credit("t1", Credit.fromCents(1000), "purchase");
+            await ledger.credit("t2", Credit.fromCents(1000), "purchase");
+            // Two entries that touch accounts in potentially reverse order.
+            // Both touch account 4000 (revenue), creating a potential lock conflict.
+            const results = await Promise.allSettled([
+                ledger.debit("t1", Credit.fromCents(50), "bot_runtime"),
+                ledger.debit("t2", Credit.fromCents(30), "bot_runtime"),
+            ]);
+            // Both should succeed — lock ordering prevents deadlock
+            expect(results.every((r) => r.status === "fulfilled")).toBe(true);
+            // Verify balances are correct
+            expect((await ledger.balance("t1")).toCentsRounded()).toBe(950);
+            expect((await ledger.balance("t2")).toCentsRounded()).toBe(970);
+            // Revenue account should reflect both debits
+            expect((await ledger.accountBalance("4000")).toCentsRounded()).toBe(80);
+            // Trial balance must still be balanced
+            const tb = await ledger.trialBalance();
+            expect(tb.balanced).toBe(true);
+        });
+        it("concurrent multi-line entries on same tenant serialize correctly", async () => {
+            await ledger.credit("t1", Credit.fromCents(1000), "purchase");
+            // Two debits on the same tenant, touching overlapping accounts.
+            const results = await Promise.allSettled([
+                ledger.debit("t1", Credit.fromCents(100), "bot_runtime"),
+                ledger.debit("t1", Credit.fromCents(200), "adapter_usage"),
+            ]);
+            expect(results.every((r) => r.status === "fulfilled")).toBe(true);
+            // Balance: $10 - $1 - $2 = $7
+            expect((await ledger.balance("t1")).toCentsRounded()).toBe(700);
+            // Revenue accounts
+            expect((await ledger.accountBalance("4000")).toCentsRounded()).toBe(100); // bot_runtime
+            expect((await ledger.accountBalance("4010")).toCentsRounded()).toBe(200); // adapter_usage
+            const tb = await ledger.trialBalance();
+            expect(tb.balanced).toBe(true);
+        });
+    });
 });

package/dist/db/schema/ledger.js

@@ -55,6 +55,9 @@ export const journalLines = pgTable("journal_lines", {
     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(),
 }, (table) => [
@@ -71,6 +74,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/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;
-    }
-}