dominus-cli 2.1.1 → 2.2.1

package/dist/bridge-daemon.js

@@ -0,0 +1,581 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import * as crypto from 'crypto';
+import { randomUUID } from 'crypto';
+import { EventEmitter } from 'events';
+import { WebSocket, WebSocketServer } from 'ws';
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
+
+var DOMINUS_DIR = path.join(os.homedir(), ".dominus");
+var CONFIG_PATH = path.join(DOMINUS_DIR, "config.json");
+path.join(DOMINUS_DIR, "dominus.db");
+path.join(DOMINUS_DIR, "rules.json");
+var DEFAULTS = {
+  provider: "openai",
+  apiBaseUrl: "",
+  model: "",
+  port: 18088,
+  maxToolIterations: 25,
+  maxVerifyRetries: 3,
+  tokenBudget: 128e3,
+  autoIndex: true,
+  autoLearn: true,
+  userName: "Developer"
+};
+function ensureDir() {
+  if (!fs.existsSync(DOMINUS_DIR)) {
+    fs.mkdirSync(DOMINUS_DIR, { recursive: true });
+  }
+}
+function readJson(filePath, defaults) {
+  try {
+    if (fs.existsSync(filePath)) {
+      const raw = fs.readFileSync(filePath, "utf-8");
+      return { ...defaults, ...JSON.parse(raw) };
+    }
+  } catch {
+  }
+  return { ...defaults };
+}
+function loadConfig() {
+  ensureDir();
+  return readJson(CONFIG_PATH, DEFAULTS);
+}
+function getDominusDir() {
+  ensureDir();
+  return DOMINUS_DIR;
+}
+var DOMINUS_PROTOCOL_VERSION = 2;
+var MAX_MESSAGE_BYTES = 1024 * 1024;
+var StudioMsg = {
+  HELLO: "studio:hello",
+  CONNECTED: "studio:connected",
+  DISCONNECTED: "studio:disconnected",
+  RESPONSE: "studio:response",
+  AUTHENTICATED: "server:authenticated",
+  AUTH_REJECTED: "server:auth_rejected"
+};
+var ControllerMsg = {
+  HELLO: "controller:hello",
+  WELCOME: "controller:welcome",
+  RELAY: "controller:relay",
+  TARGET_STATE: "controller:target_state",
+  SET_ACTIVE_CONNECTION: "controller:set_active_connection"
+};
+function createMessage(type, payload) {
+  return { id: nanoid(), type, payload, ts: Date.now() };
+}
+function parseMessage(raw) {
+  if (Buffer.byteLength(raw, "utf8") > MAX_MESSAGE_BYTES) {
+    throw new Error(`WebSocket message exceeds ${MAX_MESSAGE_BYTES} bytes`);
+  }
+  try {
+    const parsed = JSON.parse(raw);
+    return wsMessageSchema.parse(parsed);
+  } catch {
+    throw new Error(`Failed to parse WebSocket message: ${raw.slice(0, 100)}`);
+  }
+}
+function serializeMessage(msg) {
+  const serialized = JSON.stringify(msg);
+  if (Buffer.byteLength(serialized, "utf8") > MAX_MESSAGE_BYTES) {
+    throw new Error(`WebSocket message exceeds ${MAX_MESSAGE_BYTES} bytes`);
+  }
+  return serialized;
+}
+var wsMessageSchema = z.object({
+  id: z.string().min(1).max(128),
+  type: z.string().min(1).max(128),
+  payload: z.unknown(),
+  ts: z.number().finite()
+}).strict();
+var TOKEN_FILE = "bridge-token";
+function loadOrCreateBridgeToken() {
+  const tokenPath = path.join(getDominusDir(), TOKEN_FILE);
+  try {
+    const existing = fs.readFileSync(tokenPath, "utf8").trim();
+    if (existing.length >= 32) return existing;
+  } catch {
+  }
+  const token = crypto.randomBytes(32).toString("base64url");
+  fs.writeFileSync(tokenPath, `${token}
+`, { encoding: "utf8", mode: 384 });
+  try {
+    fs.chmodSync(tokenPath, 384);
+  } catch {
+  }
+  return token;
+}
+function tokensEqual(actual, expected) {
+  if (typeof actual !== "string") return false;
+  const actualBuffer = Buffer.from(actual);
+  const expectedBuffer = Buffer.from(expected);
+  return actualBuffer.length === expectedBuffer.length && crypto.timingSafeEqual(actualBuffer, expectedBuffer);
+}
+
+// src/transport/ws-server.ts
+var HANDSHAKE_TIMEOUT_MS = 8e3;
+var RATE_WINDOW_MS = 1e4;
+var RATE_LIMIT = 250;
+var DominusServer = class extends EventEmitter {
+  wss = null;
+  studioClients = /* @__PURE__ */ new Map();
+  wsToConnectionId = /* @__PURE__ */ new Map();
+  controllers = /* @__PURE__ */ new Set();
+  socketRoles = /* @__PURE__ */ new Map();
+  pendingRequests = /* @__PURE__ */ new Map();
+  relayRequests = /* @__PURE__ */ new Map();
+  rateState = /* @__PURE__ */ new Map();
+  token;
+  host;
+  maxPayloadBytes;
+  handshakeTimeoutMs;
+  activeConnectionId = null;
+  port;
+  constructor(port = 18088, options = {}) {
+    super();
+    this.port = port;
+    this.token = options.token ?? loadOrCreateBridgeToken();
+    this.host = options.host ?? "127.0.0.1";
+    this.maxPayloadBytes = options.maxPayloadBytes ?? MAX_MESSAGE_BYTES;
+    this.handshakeTimeoutMs = options.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS;
+  }
+  start(maxRetries = 0) {
+    return new Promise((resolve, reject) => {
+      const tryPort = (port, attempt) => {
+        const wss = new WebSocketServer({
+          port,
+          host: this.host,
+          maxPayload: this.maxPayloadBytes,
+          perMessageDeflate: false
+        });
+        wss.on("listening", () => {
+          this.wss = wss;
+          this.port = port;
+          wss.on("connection", (ws) => this.handleConnection(ws));
+          this.emit("server:started", { port, host: this.host });
+          resolve();
+        });
+        wss.on("error", (err) => {
+          if (err.code === "EADDRINUSE" && attempt < maxRetries) {
+            wss.close();
+            tryPort(port + 1, attempt + 1);
+            return;
+          }
+          this.emit("server:error", err);
+          reject(err);
+        });
+      };
+      tryPort(this.port, 0);
+    });
+  }
+  handleConnection(ws) {
+    this.socketRoles.set(ws, "unknown");
+    this.rateState.set(ws, { startedAt: Date.now(), count: 0 });
+    const handshakeTimer = setTimeout(() => {
+      if (this.socketRoles.get(ws) === "unknown") {
+        ws.close(1008, "Dominus handshake timed out");
+      }
+    }, this.handshakeTimeoutMs);
+    ws.on("message", (raw) => {
+      try {
+        if (!this.consumeRateBudget(ws) || rawByteLength(raw) > this.maxPayloadBytes) {
+          ws.close(1009, "Dominus message limit exceeded");
+          return;
+        }
+        const msg = parseMessage(raw.toString());
+        const role = this.socketRoles.get(ws) ?? "unknown";
+        if (role === "unknown") {
+          clearTimeout(handshakeTimer);
+          this.handleHandshake(ws, msg);
+        } else if (role === "controller") {
+          this.handleControllerMessage(ws, msg);
+        } else if (role === "studio") {
+          this.handleStudioMessage(ws, msg);
+        }
+      } catch (err) {
+        this.emit("server:error", err);
+        this.sendSafe(
+          ws,
+          createMessage(StudioMsg.AUTH_REJECTED, {
+            error: err instanceof Error ? err.message : String(err)
+          })
+        );
+      }
+    });
+    ws.on("close", () => {
+      clearTimeout(handshakeTimer);
+      this.cleanupSocket(ws);
+    });
+    ws.on("error", (err) => this.emit("server:error", err));
+  }
+  consumeRateBudget(ws) {
+    const now = Date.now();
+    const state = this.rateState.get(ws) ?? { startedAt: now, count: 0 };
+    if (now - state.startedAt >= RATE_WINDOW_MS) {
+      state.startedAt = now;
+      state.count = 0;
+    }
+    state.count += 1;
+    this.rateState.set(ws, state);
+    return state.count <= RATE_LIMIT;
+  }
+  handleHandshake(ws, msg) {
+    if (msg.type === StudioMsg.HELLO) {
+      const hello = validateStudioHello(msg.payload);
+      if (tokensEqual(hello.token, this.token)) {
+        this.authorizeStudio(ws, hello, randomUUID());
+      } else {
+        this.sendSafe(
+          ws,
+          createMessage(StudioMsg.AUTH_REJECTED, {
+            error: "Studio credentials are missing or stale. Run dominus-install-plugin."
+          })
+        );
+        ws.close(1008, "Unauthorized Studio plugin");
+      }
+      return;
+    }
+    if (msg.type === ControllerMsg.HELLO) {
+      const payload = msg.payload;
+      if (payload.protocolVersion !== DOMINUS_PROTOCOL_VERSION || !tokensEqual(payload.token, this.token)) {
+        this.sendSafe(
+          ws,
+          createMessage(StudioMsg.AUTH_REJECTED, {
+            error: "Invalid Dominus controller credentials"
+          })
+        );
+        ws.close(1008, "Unauthorized controller");
+        return;
+      }
+      this.socketRoles.set(ws, "controller");
+      this.controllers.add(ws);
+      this.sendSafe(
+        ws,
+        createMessage(ControllerMsg.WELCOME, {
+          protocolVersion: DOMINUS_PROTOCOL_VERSION,
+          port: this.port,
+          connections: this.listConnections(),
+          activeConnectionId: this.activeConnectionId
+        })
+      );
+      return;
+    }
+    this.sendSafe(
+      ws,
+      createMessage(StudioMsg.AUTH_REJECTED, {
+        error: `Expected ${StudioMsg.HELLO} or ${ControllerMsg.HELLO}`
+      })
+    );
+    ws.close(1008, "Invalid Dominus handshake");
+  }
+  authorizeStudio(ws, hello, connectionId) {
+    const connection = {
+      ws,
+      connectionId,
+      clientId: hello.clientId,
+      connectedAt: Date.now(),
+      studioVersion: hello.studioVersion,
+      placeId: hello.placeId ?? 0,
+      placeName: hello.placeName
+    };
+    this.studioClients.set(connectionId, connection);
+    this.wsToConnectionId.set(ws, connectionId);
+    this.socketRoles.set(ws, "studio");
+    if (!this.activeConnectionId || !this.studioClients.has(this.activeConnectionId)) {
+      this.activeConnectionId = connectionId;
+    }
+    this.sendSafe(
+      ws,
+      createMessage(StudioMsg.AUTHENTICATED, {
+        protocolVersion: DOMINUS_PROTOCOL_VERSION,
+        connectionId,
+        token: this.token
+      })
+    );
+    const info = this.toPlaceInfo(connection);
+    this.emit("studio:connected", info);
+    this.broadcastToControllers(StudioMsg.CONNECTED, info);
+    this.broadcastTargetState();
+    return connection;
+  }
+  handleControllerMessage(controllerWs, msg) {
+    if (msg.type === ControllerMsg.RELAY) {
+      const payload = msg.payload;
+      const request = parseMessage(JSON.stringify(payload.request));
+      const target = this.resolveConnection(
+        typeof payload.connectionId === "string" ? payload.connectionId : null
+      );
+      if (!target) {
+        this.sendResponse(controllerWs, request.id, { error: this.getTargetError() });
+        return;
+      }
+      this.relayRequests.set(request.id, { controllerWs, targetWs: target.ws });
+      this.sendSafe(target.ws, request);
+      return;
+    }
+    if (msg.type === ControllerMsg.SET_ACTIVE_CONNECTION) {
+      const payload = msg.payload;
+      const connectionId = typeof payload.connectionId === "string" ? payload.connectionId : null;
+      if (connectionId && !this.studioClients.has(connectionId)) {
+        this.sendResponse(controllerWs, msg.id, {
+          success: false,
+          error: `Studio connection ${connectionId} is not connected`
+        });
+        return;
+      }
+      this.sendResponse(controllerWs, msg.id, { success: true, connectionId });
+      return;
+    }
+    this.sendResponse(controllerWs, msg.id, {
+      error: `Unsupported controller message: ${msg.type}`
+    });
+  }
+  handleStudioMessage(ws, msg) {
+    if (msg.type === StudioMsg.RESPONSE) {
+      const relay = this.relayRequests.get(msg.id);
+      if (relay) {
+        if (relay.targetWs !== ws) {
+          this.emit(
+            "server:error",
+            new Error(`Ignored relayed response ${msg.id} from the wrong Studio session`)
+          );
+          return;
+        }
+        this.sendSafe(relay.controllerWs, msg);
+        this.relayRequests.delete(msg.id);
+        return;
+      }
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        if (pending.targetWs !== ws) {
+          this.emit(
+            "server:error",
+            new Error(`Ignored response ${msg.id} from the wrong Studio session`)
+          );
+          return;
+        }
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        pending.resolve(msg);
+      }
+      return;
+    }
+    this.emit(msg.type, msg.payload);
+    this.emit("message", msg);
+  }
+  cleanupSocket(ws) {
+    const role = this.socketRoles.get(ws);
+    this.socketRoles.delete(ws);
+    this.rateState.delete(ws);
+    if (role === "controller") {
+      this.controllers.delete(ws);
+      for (const [id, relay] of this.relayRequests) {
+        if (relay.controllerWs === ws) this.relayRequests.delete(id);
+      }
+      return;
+    }
+    const connectionId = this.wsToConnectionId.get(ws);
+    if (!connectionId) return;
+    const connection = this.studioClients.get(connectionId);
+    this.wsToConnectionId.delete(ws);
+    this.studioClients.delete(connectionId);
+    for (const [id, pending] of this.pendingRequests) {
+      if (pending.targetWs === ws) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error(`Studio disconnected (${connectionId})`));
+        this.pendingRequests.delete(id);
+      }
+    }
+    for (const [id, relay] of this.relayRequests) {
+      if (relay.targetWs === ws) {
+        this.sendResponse(relay.controllerWs, id, {
+          error: `Studio disconnected (${connectionId})`
+        });
+        this.relayRequests.delete(id);
+      }
+    }
+    if (this.activeConnectionId === connectionId) {
+      this.activeConnectionId = this.studioClients.size === 1 ? this.studioClients.keys().next().value ?? null : null;
+    }
+    const info = connection ? this.toPlaceInfo(connection) : { connectionId };
+    this.emit("studio:disconnected", info);
+    this.broadcastToControllers(StudioMsg.DISCONNECTED, info);
+    this.broadcastTargetState();
+  }
+  resolveConnection(connectionId = this.activeConnectionId) {
+    if (connectionId) {
+      const connection = this.studioClients.get(connectionId);
+      return connection?.ws.readyState === WebSocket.OPEN ? connection : null;
+    }
+    if (this.studioClients.size === 1) {
+      const connection = this.studioClients.values().next().value;
+      return connection?.ws.readyState === WebSocket.OPEN ? connection : null;
+    }
+    return null;
+  }
+  getTargetError() {
+    if (this.studioClients.size === 0) return "No authenticated Roblox Studio connection";
+    if (this.activeConnectionId)
+      return `Studio connection ${this.activeConnectionId} is unavailable`;
+    return "Multiple Studio sessions are connected. Call dominus_select_studio with a connectionId.";
+  }
+  toPlaceInfo(connection) {
+    return {
+      placeId: connection.placeId ?? 0,
+      connectionId: connection.connectionId,
+      clientId: connection.clientId,
+      placeName: connection.placeName,
+      studioVersion: connection.studioVersion,
+      connectedAt: connection.connectedAt,
+      active: connection.connectionId === this.activeConnectionId
+    };
+  }
+  broadcastToControllers(type, payload) {
+    const message = createMessage(type, payload);
+    for (const controller of this.controllers) this.sendSafe(controller, message);
+  }
+  broadcastTargetState() {
+    this.broadcastToControllers(ControllerMsg.TARGET_STATE, {
+      connections: this.listConnections(),
+      defaultActiveConnectionId: this.activeConnectionId
+    });
+  }
+  sendResponse(ws, id, payload) {
+    this.sendSafe(ws, { id, type: StudioMsg.RESPONSE, payload, ts: Date.now() });
+  }
+  sendSafe(ws, message) {
+    if (ws.readyState !== WebSocket.OPEN) return;
+    try {
+      ws.send(serializeMessage(message));
+    } catch (err) {
+      this.emit("server:error", err);
+    }
+  }
+  sendRequest(type, payload, timeoutMs = 15e3) {
+    return new Promise((resolve, reject) => {
+      const target = this.resolveConnection();
+      if (!target) {
+        reject(new Error(this.getTargetError()));
+        return;
+      }
+      const message = createMessage(type, payload);
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(message.id);
+        reject(new Error(`Studio request timed out: ${type}`));
+      }, timeoutMs);
+      this.pendingRequests.set(message.id, {
+        resolve,
+        reject,
+        timer,
+        targetWs: target.ws
+      });
+      this.sendSafe(target.ws, message);
+    });
+  }
+  sendNotification(type, payload) {
+    const target = this.resolveConnection();
+    if (target) this.sendSafe(target.ws, createMessage(type, payload));
+  }
+  isConnected() {
+    return this.resolveConnection() !== null;
+  }
+  getConnectionInfo() {
+    return this.resolveConnection();
+  }
+  listConnections() {
+    return [...this.studioClients.values()].filter(({ ws }) => ws.readyState === WebSocket.OPEN).map((connection) => this.toPlaceInfo(connection));
+  }
+  getActiveConnectionId() {
+    return this.activeConnectionId;
+  }
+  async setActiveConnectionId(connectionId) {
+    if (connectionId && !this.studioClients.has(connectionId)) {
+      throw new Error(`Studio connection ${connectionId} is not connected`);
+    }
+    this.activeConnectionId = connectionId;
+    this.broadcastTargetState();
+  }
+  getActivePlaceId() {
+    return this.resolveConnection()?.placeId ?? 0;
+  }
+  setActivePlaceId(placeId) {
+    if (placeId === 0) {
+      this.activeConnectionId = null;
+      return;
+    }
+    const matches = [...this.studioClients.values()].filter(
+      (connection) => connection.placeId === placeId
+    );
+    if (matches.length !== 1) {
+      throw new Error(
+        matches.length === 0 ? `Place ${placeId} is not connected` : `Place ${placeId} has multiple Studio sessions; select a connectionId instead`
+      );
+    }
+    this.activeConnectionId = matches[0].connectionId;
+  }
+  getPort() {
+    return this.port;
+  }
+  stop() {
+    return new Promise((resolve) => {
+      for (const pending of this.pendingRequests.values()) {
+        clearTimeout(pending.timer);
+        pending.reject(new Error("Dominus bridge is shutting down"));
+      }
+      this.pendingRequests.clear();
+      this.relayRequests.clear();
+      for (const ws of this.socketRoles.keys()) ws.close(1001, "Dominus bridge shutdown");
+      this.studioClients.clear();
+      this.controllers.clear();
+      this.socketRoles.clear();
+      this.wsToConnectionId.clear();
+      if (this.wss) this.wss.close(() => resolve());
+      else resolve();
+    });
+  }
+};
+function validateStudioHello(payload) {
+  if (!payload || typeof payload !== "object") throw new Error("Invalid Studio hello payload");
+  const hello = payload;
+  if (hello.protocolVersion !== DOMINUS_PROTOCOL_VERSION) {
+    throw new Error(
+      `Studio plugin protocol ${hello.protocolVersion ?? "unknown"} is incompatible; expected ${DOMINUS_PROTOCOL_VERSION}`
+    );
+  }
+  if (typeof hello.clientId !== "string" || hello.clientId.length < 8 || hello.clientId.length > 128) {
+    throw new Error("Studio hello is missing a valid clientId");
+  }
+  if (typeof hello.studioVersion !== "string" || hello.studioVersion.length > 128) {
+    throw new Error("Studio hello is missing studioVersion");
+  }
+  if (hello.placeName && hello.placeName.length > 256)
+    throw new Error("Studio placeName is too long");
+  return hello;
+}
+function rawByteLength(raw) {
+  if (typeof raw === "string") return Buffer.byteLength(raw);
+  if (Array.isArray(raw)) return raw.reduce((total, item) => total + item.byteLength, 0);
+  return raw.byteLength;
+}
+
+// src/transport/bridge-daemon.ts
+var configuredPort = Number(process.env.DOMINUS_BRIDGE_PORT ?? loadConfig().port);
+if (!Number.isInteger(configuredPort) || configuredPort < 1 || configuredPort > 65535) {
+  throw new Error(`Invalid Dominus bridge port: ${configuredPort}`);
+}
+var bridge = new DominusServer(configuredPort);
+await bridge.start();
+var stopping = false;
+async function stop() {
+  if (stopping) return;
+  stopping = true;
+  await bridge.stop();
+}
+process.once("SIGINT", () => void stop().finally(() => process.exit(0)));
+process.once("SIGTERM", () => void stop().finally(() => process.exit(0)));
+//# sourceMappingURL=bridge-daemon.js.map
+//# sourceMappingURL=bridge-daemon.js.map