@rivalis/fleet 8.0.0

package/lib/FleetControl.js

@@ -0,0 +1,139 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/orchestrator/FleetControl.ts
+var FleetControl_exports = {};
+__export(FleetControl_exports, {
+  FleetControl: () => FleetControl
+});
+module.exports = __toCommonJS(FleetControl_exports);
+
+// src/domain/roomId.ts
+var ROOM_ID_PATTERN = /^[A-Za-z0-9_-]{1,64}$/;
+
+// src/domain/roomCreate.ts
+var roomCreateSchema = {
+  type: { type: "string", required: true, min: 1 },
+  roomId: { type: "string", pattern: ROOM_ID_PATTERN.source },
+  placement: { type: "object" }
+};
+
+// src/domain/errors.ts
+var import_node = require("@toolcase/node");
+var CODE_TO_STATUS = {
+  VALIDATION: 400,
+  UNAUTHORIZED: 401,
+  INSTANCE_NOT_FOUND: 404,
+  ROOM_NOT_FOUND: 404,
+  NO_CANDIDATE: 409,
+  ROOM_EXISTS: 409,
+  INSTANCE_DRAINING: 409,
+  PAYLOAD_TOO_LARGE: 413,
+  INSTANCE_BUSY: 429,
+  AUTH_THROTTLED: 429,
+  SSE_LIMIT: 429,
+  COMMAND_FAILED: 502,
+  INSTANCE_DISCONNECTED: 502,
+  COMMAND_TIMEOUT: 504
+};
+var FleetError = class extends import_node.EndpointError {
+  constructor(code, message) {
+    super(CODE_TO_STATUS[code], code, message);
+    this.name = "FleetError";
+  }
+};
+
+// src/orchestrator/FleetControl.ts
+var FleetControl = class {
+  constructor(state, commands, getLink) {
+    this.state = state;
+    this.commands = commands;
+    this.getLink = getLink;
+  }
+  state;
+  commands;
+  getLink;
+  /** Place a new room and push an acknowledged `create` command (§9 command flow). */
+  async createRoom(request) {
+    const roomIdReservation = this.state.reserveRoomId(request.roomId);
+    let placement;
+    try {
+      placement = this.state.place({ type: request.type, ...request.placement ?? {} });
+    } catch (error) {
+      this.state.releaseRoomId(roomIdReservation);
+      throw error;
+    }
+    const link = this.getLink(placement.instance.id);
+    if (link === void 0) {
+      this.state.release(placement.reservation);
+      this.state.releaseRoomId(roomIdReservation);
+      throw new FleetError("INSTANCE_DISCONNECTED", `instance ${placement.instance.id} is no longer connected`);
+    }
+    const cmd = {
+      cmdId: this.commands.nextCmdId(),
+      op: "create",
+      roomId: roomIdReservation.roomId,
+      roomType: request.type
+    };
+    await this.commands.send(link, cmd, placement.reservation, roomIdReservation);
+    return {
+      id: roomIdReservation.roomId,
+      type: request.type,
+      connections: 0,
+      instanceId: placement.instance.id,
+      endpointUrl: placement.instance.endpointUrl,
+      local: false
+    };
+  }
+  /** Destroy a room by its fleet-unique public id; the orchestrator resolves the owner (§9, §10). */
+  async destroyRoom(roomId) {
+    const located = this.state.resolveRoom(roomId);
+    if (located === null) {
+      throw new FleetError("ROOM_NOT_FOUND", `room ${roomId} not found`);
+    }
+    const link = this.getLink(located.instanceId);
+    if (link === void 0) {
+      throw new FleetError("INSTANCE_DISCONNECTED", `instance ${located.instanceId} is no longer connected`);
+    }
+    await this.commands.send(link, { cmdId: this.commands.nextCmdId(), op: "destroy", roomId: located.rawRoomId });
+  }
+  /** Ask an instance to drain via `fleet/cmd {op:'drain'}` — the agent owns status (§7). */
+  drainInstance(instanceId) {
+    return this.sendStatusCommand(instanceId, "drain");
+  }
+  /** Reverse of {@link drainInstance}. */
+  undrainInstance(instanceId) {
+    return this.sendStatusCommand(instanceId, "undrain");
+  }
+  async sendStatusCommand(instanceId, op) {
+    if (this.state.getInstance(instanceId) === null) {
+      throw new FleetError("INSTANCE_NOT_FOUND", `instance ${instanceId} not found`);
+    }
+    const link = this.getLink(instanceId);
+    if (link === void 0) {
+      throw new FleetError("INSTANCE_DISCONNECTED", `instance ${instanceId} is no longer connected`);
+    }
+    await this.commands.send(link, { cmdId: this.commands.nextCmdId(), op });
+    this.state.setPendingStatus(instanceId, op === "drain" ? "draining" : "active");
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FleetControl
+});