@wopr-network/platform-core 1.38.0 → 1.39.0

package/dist/fleet/image-poller.test.js

@@ -428,36 +428,36 @@ describe("ContainerUpdater", () => {
         expect(result.error).toBe("Bot not found");
     });
     it("performs update by pulling, stopping, and recreating", async () => {
-        // The fleet.update method will be called to recreate the container
-        // We need to make sure listContainers returns properly
+        // Trace through doUpdateBot("bot-1"):
+        // 1. getContainerDigest: listContainers + getContainer + inspect + getImage
+        // 2. wasRunning check: listContainers + getContainer + inspect
+        // 3. docker.pull + followProgress
+        // 4. fleet.update(botId, { image }):
+        //    a. findContainer: listContainers + getContainer
+        //    b. inspect (wasRunning check)
+        //    c. pullImage (updates.image set): docker.pull + followProgress
+        //    d. stop + remove
+        //    e. createContainer
+        //    f. findContainer after recreate (wasRunning): listContainers + getContainer
+        //    g. start
+        // 5. waitForHealthy: listContainers + getContainer + inspect
+        // 6. getContainerDigest (final): listContainers + getContainer + inspect + getImage
         docker.listContainers
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // getContainerDigest during updateBot
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // step 2: find container to stop
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // fleet.update -> findContainer
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // fleet.update -> findContainer after recreate
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // fleet.start -> findContainer
-            .mockResolvedValueOnce([{ Id: "container-123" }]); // waitForHealthy
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 1: getContainerDigest
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 2: doUpdateBot wasRunning
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 4a: fleet.update -> findContainer
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 4f: fleet.update -> findContainer after recreate
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 5: waitForHealthy
+            .mockResolvedValueOnce([{ Id: "container-123" }]); // 6: final getContainerDigest
         docker.getContainer.mockReturnValue(container);
-        // Sequence inspect calls: first two return "running" (for wasRunning checks in
-        // doUpdateBot and fleet.update), third returns "stopped" so fleet.start()'s
-        // assertValidState guard allows the start, subsequent calls use the default (running+healthy).
         const runningInspect = {
             Id: "container-123",
             Image: "sha256:abc123",
             Created: "2026-01-01T00:00:00Z",
             State: { Status: "running", Running: true, StartedAt: "2026-01-01T00:00:00Z", Health: { Status: "healthy" } },
         };
-        const stoppedInspect = {
-            Id: "container-123",
-            Image: "sha256:abc123",
-            Created: "2026-01-01T00:00:00Z",
-            State: { Status: "stopped", Running: false, StartedAt: "2026-01-01T00:00:00Z", Health: { Status: "healthy" } },
-        };
-        container.inspect
-            .mockResolvedValueOnce(runningInspect) // getContainerDigest: initial digest check
-            .mockResolvedValueOnce(runningInspect) // doUpdateBot: wasRunning check
-            .mockResolvedValueOnce(runningInspect) // fleet.update: wasRunning check
-            .mockResolvedValueOnce(stoppedInspect); // fleet.start: assertValidState (newly recreated container)
+        // All inspect calls return running+healthy (getContainerDigest, wasRunning checks, waitForHealthy, final digest)
+        container.inspect.mockResolvedValue(runningInspect);
         const result = await updater.updateBot("bot-1");
         expect(result.success).toBe(true);
         expect(result.rolledBack).toBe(false);
@@ -469,34 +469,25 @@ describe("ContainerUpdater", () => {
         docker.modem.followProgress.mockImplementationOnce((_stream, cb) => {
             resolvePull = cb;
         });
+        // After the first followProgress (which hangs), subsequent calls use default (instant resolve)
+        // Trace: getContainerDigest, wasRunning, fleet.update->findContainer,
+        //   fleet.update->findContainer after recreate, waitForHealthy, final getContainerDigest
         docker.listContainers
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // first update: getContainerDigest
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // first update: step 2
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // fleet.update
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // fleet.start
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // waitForHealthy
-            .mockResolvedValueOnce([{ Id: "container-123" }]); // get new digest
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 1: getContainerDigest
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 2: doUpdateBot wasRunning
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 4a: fleet.update -> findContainer
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 4f: fleet.update -> findContainer after recreate
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 5: waitForHealthy
+            .mockResolvedValueOnce([{ Id: "container-123" }]); // 6: final getContainerDigest
         docker.getContainer.mockReturnValue(container);
-        // Sequence inspect calls: first two return "running" (for wasRunning checks in
-        // doUpdateBot and fleet.update), third returns "stopped" so fleet.start()'s
-        // assertValidState guard allows the start.
         const runningInspect = {
             Id: "container-123",
             Image: "sha256:abc123",
             Created: "2026-01-01T00:00:00Z",
             State: { Status: "running", Running: true, StartedAt: "2026-01-01T00:00:00Z", Health: { Status: "healthy" } },
         };
-        const stoppedInspect = {
-            Id: "container-123",
-            Image: "sha256:abc123",
-            Created: "2026-01-01T00:00:00Z",
-            State: { Status: "stopped", Running: false, StartedAt: "2026-01-01T00:00:00Z", Health: { Status: "healthy" } },
-        };
-        container.inspect
-            .mockResolvedValueOnce(runningInspect) // getContainerDigest: initial digest check
-            .mockResolvedValueOnce(runningInspect) // doUpdateBot: wasRunning check
-            .mockResolvedValueOnce(runningInspect) // fleet.update: wasRunning check
-            .mockResolvedValueOnce(stoppedInspect); // fleet.start: assertValidState (newly recreated container)
+        // All inspect calls return running+healthy
+        container.inspect.mockResolvedValue(runningInspect);
         // Start first update (will block on pull)
         const first = updater.updateBot("bot-1");
         // Wait for the pull to be called so the lock is held
@@ -517,6 +508,7 @@ describe("ContainerUpdater", () => {
         const unhealthyContainer = mockContainer({
             inspect: vi.fn().mockResolvedValue({
                 Id: "container-123",
+                Name: "/wopr-test-bot",
                 Image: "sha256:new999",
                 Created: "2026-01-01T00:00:00Z",
                 State: {
@@ -525,23 +517,46 @@ describe("ContainerUpdater", () => {
                     StartedAt: "2026-01-01T00:00:00Z",
                     Health: { Status: "unhealthy" },
                 },
+                NetworkSettings: { Ports: {} },
             }),
         });
-        // Make the new container unhealthy so rollback happens
+        // Trace through doUpdateBot("bot-1"):
+        // 1. getContainerDigest: listContainers + getContainer + inspect + getImage
+        // 2. wasRunning check: listContainers + getContainer + inspect
+        // 3. docker.pull + followProgress
+        // 4. fleet.update(botId, { image }):
+        //    a. findContainer: listContainers + getContainer
+        //    b. inspect (wasRunning check in update)
+        //    c. pullImage (updates.image is set): docker.pull + followProgress
+        //    d. stop + remove
+        //    e. createContainer
+        //    f. findContainer after recreate (wasRunning): listContainers + getContainer
+        //    g. start
+        // 5. waitForHealthy: listContainers + getContainer + inspect
+        // 6. unhealthy -> rollback via fleet.update:
+        //    a. findContainer: listContainers + getContainer
+        //    b. inspect (wasRunning)
+        //    c. pullImage: docker.pull + followProgress
+        //    d. stop + remove
+        //    e. createContainer
+        //    f. findContainer after recreate (wasRunning): listContainers + getContainer
+        //    g. start
         docker.listContainers
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // getContainerDigest
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // step 2: find container to stop
-            .mockResolvedValueOnce([]) // fleet.update -> findContainer (no existing)
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // fleet.start
-            .mockResolvedValueOnce([{ Id: "container-123" }]) // waitForHealthy
-            .mockResolvedValueOnce([]) // rollback fleet.update -> findContainer
-            .mockResolvedValueOnce([{ Id: "container-123" }]); // rollback fleet.start
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 1: getContainerDigest
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 2: doUpdateBot wasRunning
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 4a: fleet.update -> findContainer
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 4f: fleet.update -> findContainer after recreate
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 5: waitForHealthy
+            .mockResolvedValueOnce([{ Id: "container-123" }]) // 6a: rollback fleet.update -> findContainer
+            .mockResolvedValueOnce([{ Id: "container-123" }]); // 6f: rollback fleet.update -> findContainer after recreate
         docker.getContainer
-            .mockReturnValueOnce(container) // getContainerDigest inspect
-            .mockReturnValueOnce(container) // step 2: stop + remove
-            .mockReturnValueOnce(container) // fleet.start
-            .mockReturnValueOnce(unhealthyContainer) // waitForHealthy inspect
-            .mockReturnValueOnce(container); // rollback fleet.start
+            .mockReturnValueOnce(container) // 1: getContainerDigest
+            .mockReturnValueOnce(container) // 2: doUpdateBot wasRunning
+            .mockReturnValueOnce(container) // 4a: fleet.update -> findContainer (stop+remove this)
+            .mockReturnValueOnce(container) // 4f: fleet.update -> findContainer after recreate (start)
+            .mockReturnValueOnce(unhealthyContainer) // 5: waitForHealthy -> unhealthy
+            .mockReturnValueOnce(container) // 6a: rollback fleet.update -> findContainer (stop+remove)
+            .mockReturnValueOnce(container); // 6f: rollback fleet.update -> findContainer after recreate (start)
         const result = await updater.updateBot("bot-1");
         expect(result.success).toBe(false);
         expect(result.rolledBack).toBe(true);

package/dist/fleet/index.d.ts

@@ -3,6 +3,7 @@ export * from "./fleet-manager.js";
 export type { FleetNotificationListenerDeps } from "./fleet-notification-listener.js";
 export { initFleetNotificationListener } from "./fleet-notification-listener.js";
 export * from "./init-fleet-updater.js";
+export * from "./instance.js";
 export * from "./repository-types.js";
 export * from "./rollout-orchestrator.js";
 export * from "./rollout-strategy.js";

package/dist/fleet/index.js

@@ -2,6 +2,7 @@ export * from "./drizzle-tenant-update-config-repository.js";
 export * from "./fleet-manager.js";
 export { initFleetNotificationListener } from "./fleet-notification-listener.js";
 export * from "./init-fleet-updater.js";
+export * from "./instance.js";
 export * from "./repository-types.js";
 export * from "./rollout-orchestrator.js";
 export * from "./rollout-strategy.js";

package/dist/fleet/instance.d.ts

@@ -0,0 +1,54 @@
+import type Docker from "dockerode";
+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";
+/**
+ * Instance — a runtime handle to a container.
+ *
+ * FleetManager is the factory: pull image, create container, return Instance.
+ * Instance owns its lifecycle: start, stop, remove, setupBilling, setupProxy.
+ *
+ * Ephemeral instances (e.g., holyshippers) skip billing and proxy setup.
+ * They bill per-token at the gateway layer, not per-instance.
+ */
+export interface InstanceDeps {
+    docker: Docker;
+    profile: BotProfile;
+    containerId: string;
+    containerName: string;
+    url: string;
+    /** Optional — non-ephemeral instances use these for billing/proxy/events */
+    instanceRepo?: IBotInstanceRepository;
+    proxyManager?: ProxyManagerInterface;
+    eventEmitter?: FleetEventEmitter;
+}
+export declare class Instance {
+    readonly id: string;
+    readonly containerId: string;
+    readonly containerName: string;
+    readonly url: string;
+    readonly profile: BotProfile;
+    private readonly docker;
+    private readonly instanceRepo;
+    private readonly proxyManager;
+    private readonly eventEmitter;
+    constructor(deps: InstanceDeps);
+    /** 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">;
+    /**
+     * Register this instance in the billing system.
+     * Skip for ephemeral instances — they bill per-token, not per-instance.
+     */
+    setupBilling(): Promise<void>;
+    /**
+     * Register a proxy route for tenant subdomain routing.
+     * Skip for ephemeral instances — they're accessed directly via Docker DNS.
+     */
+    setupProxy(): Promise<void>;
+    private emit;
+}

package/dist/fleet/instance.js

@@ -0,0 +1,136 @@
+import { logger } from "../config/logger.js";
+export class Instance {
+    id;
+    containerId;
+    containerName;
+    url;
+    profile;
+    docker;
+    instanceRepo;
+    proxyManager;
+    eventEmitter;
+    constructor(deps) {
+        this.id = deps.profile.id;
+        this.containerId = deps.containerId;
+        this.containerName = deps.containerName;
+        this.url = deps.url;
+        this.profile = deps.profile;
+        this.docker = deps.docker;
+        this.instanceRepo = deps.instanceRepo;
+        this.proxyManager = deps.proxyManager;
+        this.eventEmitter = deps.eventEmitter;
+    }
+    /** 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");
+    }
+    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;
+            }
+        }
+        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;
+            }
+        }
+        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() {
+        try {
+            const container = this.docker.getContainer(this.containerId);
+            const info = await container.inspect();
+            return info.State.Running ? "running" : "stopped";
+        }
+        catch {
+            return "gone";
+        }
+    }
+    /**
+     * Register this instance in the billing system.
+     * Skip for ephemeral instances — they bill per-token, not per-instance.
+     */
+    async setupBilling() {
+        if (this.profile.ephemeral) {
+            logger.info("Skipping billing setup (ephemeral)", { id: this.id });
+            return;
+        }
+        if (!this.instanceRepo) {
+            logger.warn("No instance repo — billing setup skipped", { id: this.id });
+            return;
+        }
+        await this.instanceRepo.register(this.id, this.profile.tenantId, this.profile.name);
+        logger.info("Billing registered", { id: this.id, tenantId: this.profile.tenantId });
+    }
+    /**
+     * Register a proxy route for tenant subdomain routing.
+     * Skip for ephemeral instances — they're accessed directly via Docker DNS.
+     */
+    async setupProxy() {
+        if (this.profile.ephemeral) {
+            logger.info("Skipping proxy setup (ephemeral)", { id: this.id });
+            return;
+        }
+        if (!this.proxyManager) {
+            logger.warn("No proxy manager — proxy setup skipped", { id: this.id });
+            return;
+        }
+        try {
+            const subdomain = this.profile.name.toLowerCase().replace(/_/g, "-");
+            const envPort = this.profile.env?.PORT;
+            const upstreamPort = envPort ? Number.parseInt(envPort, 10) || 7437 : 7437;
+            await this.proxyManager.addRoute({
+                instanceId: this.id,
+                subdomain,
+                upstreamHost: this.containerName,
+                upstreamPort,
+                healthy: true,
+            });
+            logger.info("Proxy route registered", { id: this.id, subdomain });
+        }
+        catch (err) {
+            logger.warn("Proxy route registration failed (non-fatal)", { id: this.id, err });
+        }
+    }
+    emit(type) {
+        if (this.eventEmitter) {
+            this.eventEmitter.emit({
+                type,
+                botId: this.id,
+                tenantId: this.profile.tenantId,
+                timestamp: new Date().toISOString(),
+            });
+        }
+    }
+}

package/dist/fleet/updater.js

@@ -100,15 +100,11 @@ export class ContainerUpdater {
                         resolve();
                 });
             });
-            // Step 2: Delegate stop -> remove -> recreate to FleetManager.update().
-            // fleet.update() already implements: stop old -> remove old -> create new,
+            // Step 2: Delegate stop -> remove -> recreate -> start to FleetManager.update().
+            // fleet.update() already implements: stop old -> remove old -> create new -> start if was running,
             // with profile rollback if container creation fails.
             await this.fleet.update(botId, { image: profile.image });
-            // Step 3: Start the new container only if the old one was running
-            if (wasRunning) {
-                await this.fleet.start(botId);
-            }
-            // Step 4: Verify health (only meaningful if container is running)
+            // Step 3: Verify health (only meaningful if container is running)
             if (wasRunning) {
                 const healthy = await this.waitForHealthy(botId);
                 if (!healthy) {
@@ -196,19 +192,14 @@ export class ContainerUpdater {
      * Roll back to a previous image by updating the bot profile and recreating.
      * Only starts the container on rollback if it was running before the update.
      */
-    async rollback(botId, previousImage, previousDigest, wasRunning) {
+    async rollback(botId, previousImage, previousDigest, _wasRunning) {
         // Use digest-pinned image reference when available to prevent rollback
         // from pulling a newer image that was pushed between the update and rollback.
         const rollbackImage = previousDigest ? `${previousImage.split(":")[0]}@${previousDigest}` : previousImage;
         logger.info(`Rolling back bot ${botId} to ${rollbackImage}`);
         try {
+            // fleet.update() handles stop -> remove -> recreate -> start-if-was-running internally
             await this.fleet.update(botId, { image: rollbackImage });
-            // Only start on rollback if the container was running before the update
-            if (wasRunning) {
-                await this.fleet.start(botId).catch((err) => {
-                    logger.warn(`Failed to start bot ${botId} during rollback (may already be running)`, { err });
-                });
-            }
             return {
                 botId,
                 success: false,

package/dist/fleet/updater.test.js

@@ -66,7 +66,6 @@ function mockDocker(container = null) {
 function mockFleet() {
     return {
         update: vi.fn().mockResolvedValue(undefined),
-        start: vi.fn().mockResolvedValue(undefined),
     };
 }
 function mockPoller() {
@@ -131,7 +130,6 @@ describe("ContainerUpdater", () => {
             // Verify the update pipeline was called
             expect(docker.pull).toHaveBeenCalledWith("ghcr.io/wopr-network/wopr:stable");
             expect(fleet.update).toHaveBeenCalledWith("bot-1", { image: "ghcr.io/wopr-network/wopr:stable" });
-            expect(fleet.start).toHaveBeenCalledWith("bot-1");
         });
         it("skips start and health check when container was not running", async () => {
             const stoppedContainer = mockContainer({
@@ -154,7 +152,6 @@ describe("ContainerUpdater", () => {
             const result = await updater.updateBot("bot-1");
             expect(result.success).toBe(true);
             expect(fleet.update).toHaveBeenCalled();
-            expect(fleet.start).not.toHaveBeenCalled();
         });
         it("considers container healthy when no HEALTHCHECK is configured", async () => {
             const noHealthContainer = mockContainer({
@@ -221,8 +218,6 @@ describe("ContainerUpdater", () => {
             expect(fleet.update).toHaveBeenLastCalledWith("bot-1", {
                 image: "ghcr.io/wopr-network/wopr@sha256:abc123",
             });
-            // Rollback starts the container since it was running
-            expect(fleet.start).toHaveBeenCalledTimes(2);
         });
         it("rolls back when health check times out (stays in starting)", async () => {
             const startingContainer = mockContainer({
@@ -257,16 +252,18 @@ describe("ContainerUpdater", () => {
         });
     });
     // --- Rollback on startup failure ---
-    describe("rollback on startup failure", () => {
-        it("rolls back when fleet.start throws", async () => {
+    describe("rollback on update failure", () => {
+        it("rolls back when fleet.update throws (start embedded in update)", async () => {
             // getContainerDigest
             docker.listContainers.mockResolvedValueOnce([{ Id: "container-123" }]);
             docker.getContainer.mockReturnValueOnce(container);
             // wasRunning check
             docker.listContainers.mockResolvedValueOnce([{ Id: "container-123" }]);
             docker.getContainer.mockReturnValueOnce(container);
-            // fleet.start fails after fleet.update succeeds
-            fleet.start.mockRejectedValueOnce(new Error("Container start failed"));
+            // fleet.update fails (which now includes starting the container)
+            fleet.update
+                .mockRejectedValueOnce(new Error("Container start failed"))
+                .mockResolvedValueOnce(undefined); // rollback update succeeds
             const result = await updater.updateBot("bot-1");
             expect(result.success).toBe(false);
             expect(result.rolledBack).toBe(true);
@@ -282,12 +279,10 @@ describe("ContainerUpdater", () => {
             // wasRunning check
             docker.listContainers.mockResolvedValueOnce([{ Id: "container-123" }]);
             docker.getContainer.mockReturnValueOnce(container);
-            // fleet.start fails
-            fleet.start.mockRejectedValueOnce(new Error("Container start failed"));
-            // fleet.update (rollback) also fails
+            // fleet.update fails, then rollback fleet.update also fails
             fleet.update
-                .mockResolvedValueOnce(undefined) // initial update succeeds
-                .mockRejectedValueOnce(new Error("Rollback recreate failed")); // rollback fails
+                .mockRejectedValueOnce(new Error("Container start failed"))
+                .mockRejectedValueOnce(new Error("Rollback recreate failed"));
             const result = await updater.updateBot("bot-1");
             expect(result.success).toBe(false);
             expect(result.rolledBack).toBe(false);
@@ -548,8 +543,6 @@ describe("ContainerUpdater", () => {
             const result = await updater.updateBot("bot-1");
             expect(result.success).toBe(false);
             expect(result.rolledBack).toBe(true);
-            // fleet.start should NOT be called at all — container was stopped
-            expect(fleet.start).not.toHaveBeenCalled();
         });
     });
     // --- Edge case: wasRunning detection failure ---
@@ -565,8 +558,6 @@ describe("ContainerUpdater", () => {
             docker.getContainer.mockReturnValueOnce(container);
             const result = await updater.updateBot("bot-1");
             expect(result.success).toBe(true);
-            // Since wasRunning defaults to false on error, start and health check are skipped
-            expect(fleet.start).not.toHaveBeenCalled();
         });
     });
 });

package/dist/node-agent/types.d.ts

@@ -46,9 +46,9 @@ export declare const commandSchema: z.ZodObject<{
     type: z.ZodEnum<{
         "bot.logs": "bot.logs";
         "bot.start": "bot.start";
-        "bot.stop": "bot.stop";
         "bot.restart": "bot.restart";
         "bot.remove": "bot.remove";
+        "bot.stop": "bot.stop";
         "bot.update": "bot.update";
         "bot.export": "bot.export";
         "bot.import": "bot.import";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wopr-network/platform-core",
-  "version": "1.38.0",
+  "version": "1.39.0",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

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

@@ -12,8 +12,10 @@ function mockContainer() {
     remove: vi.fn().mockResolvedValue(undefined),
     inspect: vi.fn().mockResolvedValue({
       Id: "container-123",
+      Name: "/wopr-test",
       Created: "2026-01-01T00:00:00Z",
       State: { Status: "running", Running: true, StartedAt: "2026-01-01T00:00:00Z" },
+      NetworkSettings: { Ports: {} },
     }),
     stats: vi.fn().mockResolvedValue({
       cpu_stats: { cpu_usage: { total_usage: 200 }, system_cpu_usage: 2000, online_cpus: 2 },
@@ -28,7 +30,7 @@ function makeDocker(): Docker {
   return {
     pull: vi.fn().mockResolvedValue("stream"),
     createContainer: vi.fn().mockResolvedValue(mockContainer()),
-    listContainers: vi.fn().mockResolvedValue([]),
+    listContainers: vi.fn().mockResolvedValue([{ Id: "container-123" }]),
     getContainer: vi.fn().mockReturnValue(mockContainer()),
     modem: {
       followProgress: vi.fn((_stream: unknown, cb: (err: Error | null) => void) => cb(null)),