dominus-cli 2.2.0 → 2.2.1

package/dist/install-plugin.js

@@ -1,77 +1,547 @@
 #!/usr/bin/env node
-import fs3 from 'fs';
+import fs4 from 'fs';
 import os2 from 'os';
-import path3 from 'path';
+import path4 from 'path';
 import { fileURLToPath } from 'url';
+import { spawn } from 'child_process';
+import { EventEmitter } from 'events';
+import { WebSocket } from 'ws';
+import { nanoid } from 'nanoid';
+import { z } from 'zod';
 import * as crypto from 'crypto';
 
-var DOMINUS_DIR = path3.join(os2.homedir(), ".dominus");
-path3.join(DOMINUS_DIR, "config.json");
-path3.join(DOMINUS_DIR, "dominus.db");
-path3.join(DOMINUS_DIR, "rules.json");
+var DOMINUS_DIR = path4.join(os2.homedir(), ".dominus");
+var CONFIG_PATH = path4.join(DOMINUS_DIR, "config.json");
+path4.join(DOMINUS_DIR, "dominus.db");
+path4.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 (!fs3.existsSync(DOMINUS_DIR)) {
-    fs3.mkdirSync(DOMINUS_DIR, { recursive: true });
+  if (!fs4.existsSync(DOMINUS_DIR)) {
+    fs4.mkdirSync(DOMINUS_DIR, { recursive: true });
   }
 }
+function readJson(filePath, defaults) {
+  try {
+    if (fs4.existsSync(filePath)) {
+      const raw = fs4.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;
 }
-
-// src/transport/auth.ts
+var DOMINUS_PROTOCOL_VERSION = 2;
+var MAX_MESSAGE_BYTES = 1024 * 1024;
+var StudioMsg = {
+  HELLO: "studio:hello",
+  CONNECTED: "studio:connected",
+  DISCONNECTED: "studio:disconnected",
+  EXPLORER: "studio:explorer",
+  OUTPUT: "studio:output",
+  ERROR: "studio:error",
+  SELECTION: "studio:selection",
+  SCRIPT_CONTENT: "studio:script:content",
+  SCRIPT_CHANGED: "studio:script:changed",
+  RESPONSE: "studio:response",
+  REFLECTION: "studio:reflection",
+  TEST_RESULTS: "studio:test:results",
+  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 = path3.join(getDominusDir(), TOKEN_FILE);
+  const tokenPath = path4.join(getDominusDir(), TOKEN_FILE);
   try {
-    const existing = fs3.readFileSync(tokenPath, "utf8").trim();
+    const existing = fs4.readFileSync(tokenPath, "utf8").trim();
     if (existing.length >= 32) return existing;
   } catch {
   }
   const token = crypto.randomBytes(32).toString("base64url");
-  fs3.writeFileSync(tokenPath, `${token}
+  fs4.writeFileSync(tokenPath, `${token}
 `, { encoding: "utf8", mode: 384 });
   try {
-    fs3.chmodSync(tokenPath, 384);
+    fs4.chmodSync(tokenPath, 384);
   } catch {
   }
   return token;
 }
 
+// src/transport/ws-client.ts
+var DominusClient = class extends EventEmitter {
+  ws = null;
+  port;
+  token;
+  connectTimeoutMs;
+  connections = /* @__PURE__ */ new Map();
+  activeConnectionId = null;
+  pendingRequests = /* @__PURE__ */ new Map();
+  constructor(port = 18088, options = {}) {
+    super();
+    this.port = port;
+    this.token = options.token ?? loadOrCreateBridgeToken();
+    this.connectTimeoutMs = options.connectTimeoutMs ?? 8e3;
+  }
+  connect() {
+    return new Promise((resolve, reject) => {
+      const ws = new WebSocket(`ws://127.0.0.1:${this.port}`, {
+        perMessageDeflate: false,
+        maxPayload: 1024 * 1024
+      });
+      let settled = false;
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          ws.close(1008, "Dominus controller handshake timed out");
+          reject(new Error("Timed out authenticating with the Dominus bridge"));
+        }
+      }, this.connectTimeoutMs);
+      ws.on("open", () => {
+        this.ws = ws;
+        ws.send(
+          serializeMessage(
+            createMessage(ControllerMsg.HELLO, {
+              protocolVersion: DOMINUS_PROTOCOL_VERSION,
+              token: this.token
+            })
+          )
+        );
+      });
+      ws.on("message", (raw) => {
+        try {
+          const msg = parseMessage(raw.toString());
+          if (msg.type === ControllerMsg.WELCOME && !settled) {
+            settled = true;
+            clearTimeout(timer);
+            this.applyWelcome(msg.payload);
+            this.emit("server:started", { port: this.port, relay: true });
+            resolve();
+            return;
+          }
+          if (msg.type === StudioMsg.AUTH_REJECTED && !settled) {
+            settled = true;
+            clearTimeout(timer);
+            const payload = msg.payload;
+            reject(new Error(payload.error ?? "Dominus controller authentication failed"));
+            ws.close(1008, "Controller authentication failed");
+            return;
+          }
+          this.handleMessage(msg);
+        } catch (err) {
+          this.emit("server:error", err);
+        }
+      });
+      ws.on("close", () => {
+        clearTimeout(timer);
+        this.ws = null;
+        this.connections.clear();
+        this.activeConnectionId = null;
+        if (!settled) {
+          settled = true;
+          reject(new Error("Dominus bridge closed before authentication completed"));
+        }
+        this.rejectPending(new Error("Dominus relay connection lost"));
+        this.emit("studio:disconnected");
+      });
+      ws.on("error", (err) => {
+        if (!settled) {
+          settled = true;
+          clearTimeout(timer);
+          reject(err);
+        }
+        this.emit("server:error", err);
+      });
+    });
+  }
+  applyWelcome(payload) {
+    const welcome = payload;
+    this.replaceConnections(welcome.connections ?? []);
+    this.activeConnectionId = welcome.activeConnectionId ?? null;
+    if (!this.resolveTargetInfo() && this.connections.size === 1) {
+      this.activeConnectionId = this.connections.keys().next().value ?? null;
+    }
+  }
+  handleMessage(msg) {
+    if (msg.type === ControllerMsg.TARGET_STATE) {
+      const payload = msg.payload;
+      this.replaceConnections(payload.connections ?? []);
+      if (this.activeConnectionId && !this.connections.has(this.activeConnectionId)) {
+        this.activeConnectionId = null;
+      }
+      if (!this.activeConnectionId && this.connections.size === 1) {
+        this.activeConnectionId = this.connections.keys().next().value ?? null;
+      }
+      this.emit("controller:target_state", payload);
+      return;
+    }
+    if (msg.type === StudioMsg.CONNECTED) {
+      const connection = msg.payload;
+      this.connections.set(connection.connectionId, toConnectionInfo(connection));
+      if (!this.activeConnectionId && this.connections.size === 1) {
+        this.activeConnectionId = connection.connectionId;
+      }
+      this.emit("studio:connected", connection);
+      return;
+    }
+    if (msg.type === StudioMsg.DISCONNECTED) {
+      const payload = msg.payload;
+      if (payload.connectionId) this.connections.delete(payload.connectionId);
+      if (this.activeConnectionId === payload.connectionId) this.activeConnectionId = null;
+      if (!this.activeConnectionId && this.connections.size === 1) {
+        this.activeConnectionId = this.connections.keys().next().value ?? null;
+      }
+      this.emit("studio:disconnected", payload);
+      return;
+    }
+    if (msg.type === StudioMsg.RESPONSE) {
+      const pending = this.pendingRequests.get(msg.id);
+      if (pending) {
+        clearTimeout(pending.timer);
+        this.pendingRequests.delete(msg.id);
+        pending.resolve(msg);
+      }
+      return;
+    }
+    this.emit(msg.type, msg.payload);
+    this.emit("message", msg);
+  }
+  replaceConnections(connections) {
+    this.connections.clear();
+    for (const connection of connections) {
+      this.connections.set(connection.connectionId, toConnectionInfo(connection));
+    }
+  }
+  sendMessage(message) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) {
+      throw new Error("Not connected to the Dominus bridge");
+    }
+    this.ws.send(serializeMessage(message));
+  }
+  waitForResponse(message, timeoutMs) {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(message.id);
+        reject(new Error(`Dominus request timed out: ${message.type}`));
+      }, timeoutMs);
+      this.pendingRequests.set(message.id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        this.sendMessage(message);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(message.id);
+        reject(err);
+      }
+    });
+  }
+  async sendControlRequest(type, payload, timeoutMs = 1e4) {
+    const response = await this.waitForResponse(createMessage(type, payload), timeoutMs);
+    const result = response.payload;
+    if (result.error || result.success === false) throw new Error(result.error ?? `${type} failed`);
+    return result;
+  }
+  sendRequest(type, payload, timeoutMs = 15e3) {
+    const target = this.resolveTargetInfo();
+    if (!target || !this.activeConnectionId) {
+      return Promise.reject(
+        new Error(
+          this.connections.size > 1 ? "Multiple Studio sessions are connected. Call dominus_select_studio first." : "No authenticated Roblox Studio connection"
+        )
+      );
+    }
+    const request = createMessage(type, payload);
+    const relay = createMessage(ControllerMsg.RELAY, {
+      connectionId: this.activeConnectionId,
+      request
+    });
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pendingRequests.delete(request.id);
+        reject(new Error(`Studio request timed out: ${type}`));
+      }, timeoutMs);
+      this.pendingRequests.set(request.id, {
+        resolve,
+        reject,
+        timer
+      });
+      try {
+        this.sendMessage(relay);
+      } catch (err) {
+        clearTimeout(timer);
+        this.pendingRequests.delete(request.id);
+        reject(err);
+      }
+    });
+  }
+  sendNotification(type, payload) {
+    if (!this.activeConnectionId) return;
+    const request = createMessage(type, payload);
+    this.sendMessage(
+      createMessage(ControllerMsg.RELAY, {
+        connectionId: this.activeConnectionId,
+        request
+      })
+    );
+  }
+  isConnected() {
+    return this.resolveTargetInfo() !== null;
+  }
+  getConnectionInfo() {
+    const target = this.resolveTargetInfo();
+    if (!target || !this.ws) return null;
+    return { ...target, ws: this.ws };
+  }
+  listConnections() {
+    return [...this.connections.values()].map((connection) => ({
+      placeId: connection.placeId ?? 0,
+      connectionId: connection.connectionId,
+      clientId: connection.clientId,
+      placeName: connection.placeName,
+      studioVersion: connection.studioVersion,
+      connectedAt: connection.connectedAt,
+      active: connection.connectionId === this.activeConnectionId
+    }));
+  }
+  getActiveConnectionId() {
+    return this.activeConnectionId;
+  }
+  async setActiveConnectionId(connectionId) {
+    if (connectionId && !this.connections.has(connectionId)) {
+      throw new Error(`Studio connection ${connectionId} is not connected`);
+    }
+    await this.sendControlRequest(ControllerMsg.SET_ACTIVE_CONNECTION, { connectionId });
+    this.activeConnectionId = connectionId;
+  }
+  getActivePlaceId() {
+    return this.resolveTargetInfo()?.placeId ?? 0;
+  }
+  setActivePlaceId(placeId) {
+    if (placeId === 0) {
+      void this.setActiveConnectionId(null);
+      return;
+    }
+    const matches = [...this.connections.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`
+      );
+    }
+    void this.setActiveConnectionId(matches[0].connectionId);
+  }
+  resolveTargetInfo() {
+    if (this.activeConnectionId) return this.connections.get(this.activeConnectionId) ?? null;
+    if (this.connections.size === 1) return this.connections.values().next().value ?? null;
+    return null;
+  }
+  getPort() {
+    return this.port;
+  }
+  stop() {
+    this.rejectPending(new Error("Dominus client is shutting down"));
+    return new Promise((resolve) => {
+      if (!this.ws) {
+        resolve();
+        return;
+      }
+      const ws = this.ws;
+      this.ws = null;
+      ws.once("close", resolve);
+      ws.close(1e3, "Dominus client shutdown");
+    });
+  }
+  rejectPending(error) {
+    for (const pending of this.pendingRequests.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(error);
+    }
+    this.pendingRequests.clear();
+  }
+};
+function toConnectionInfo(connection) {
+  return {
+    connectedAt: connection.connectedAt,
+    connectionId: connection.connectionId,
+    clientId: connection.clientId,
+    studioVersion: connection.studioVersion,
+    placeId: connection.placeId,
+    placeName: connection.placeName
+  };
+}
+async function isPortInUse(port) {
+  return new Promise((resolve) => {
+    const ws = new WebSocket(`ws://127.0.0.1:${port}`);
+    const timer = setTimeout(() => {
+      ws.close();
+      resolve(false);
+    }, 750);
+    ws.on("open", () => {
+      clearTimeout(timer);
+      ws.close();
+      resolve(true);
+    });
+    ws.on("error", () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
+// src/transport/daemon-launcher.ts
+function resolveDaemonPath() {
+  const besideEntry = fileURLToPath(new URL("./bridge-daemon.js", import.meta.url));
+  if (fs4.existsSync(besideEntry)) return besideEntry;
+  const projectBuild = path4.resolve(
+    path4.dirname(fileURLToPath(import.meta.url)),
+    "../../dist/bridge-daemon.js"
+  );
+  if (fs4.existsSync(projectBuild)) return projectBuild;
+  throw new Error("Dominus bridge daemon is missing. Reinstall or rebuild dominus-cli.");
+}
+function launchBridgeDaemon(port, daemonPath = resolveDaemonPath()) {
+  const child = spawn(process.execPath, [daemonPath], {
+    detached: true,
+    env: { ...process.env, DOMINUS_BRIDGE_PORT: String(port) },
+    stdio: "ignore",
+    windowsHide: true
+  });
+  child.unref();
+}
+async function connectController(port, timeoutMs, token) {
+  const client = new DominusClient(port, { connectTimeoutMs: timeoutMs, token });
+  try {
+    await client.connect();
+    return client;
+  } catch (error) {
+    await client.stop().catch(() => void 0);
+    throw error;
+  }
+}
+async function ensureBridgeDaemon(port, options = {}) {
+  const attempts = options.attempts ?? 30;
+  const connectTimeoutMs = options.connectTimeoutMs ?? 750;
+  const retryDelayMs = options.retryDelayMs ?? 100;
+  try {
+    return await connectController(port, connectTimeoutMs, options.token);
+  } catch (initialError) {
+    if (await isPortInUse(port)) {
+      throw new Error(
+        `Port ${port} is occupied by a process that is not this Dominus bridge: ${formatError(initialError)}`
+      );
+    }
+  }
+  const launch = options.launch ?? ((targetPort) => launchBridgeDaemon(targetPort, options.daemonPath));
+  launch(port);
+  let lastError;
+  for (let attempt = 0; attempt < attempts; attempt += 1) {
+    await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
+    try {
+      return await connectController(port, connectTimeoutMs, options.token);
+    } catch (error) {
+      lastError = error;
+    }
+  }
+  throw new Error(
+    `Dominus could not start its local Studio bridge on port ${port}: ${formatError(lastError)}`
+  );
+}
+function formatError(error) {
+  return error instanceof Error ? error.message : String(error ?? "unknown error");
+}
+
 // src/install-plugin.ts
 var TOKEN_PLACEHOLDER = "__DOMINUS_BRIDGE_TOKEN__";
 function getPluginDirectory() {
   if (process.platform === "win32") {
     const localAppData = process.env.LOCALAPPDATA;
     if (!localAppData) throw new Error("LOCALAPPDATA is not set");
-    return path3.join(localAppData, "Roblox", "Plugins");
+    return path4.join(localAppData, "Roblox", "Plugins");
   }
   if (process.platform === "darwin") {
-    return path3.join(os2.homedir(), "Documents", "Roblox", "Plugins");
+    return path4.join(os2.homedir(), "Documents", "Roblox", "Plugins");
   }
-  return path3.join(os2.homedir(), ".local", "share", "Roblox", "Plugins");
+  return path4.join(os2.homedir(), ".local", "share", "Roblox", "Plugins");
 }
-var distDirectory = path3.dirname(fileURLToPath(import.meta.url));
-var source = path3.resolve(distDirectory, "..", "plugin", "Dominus.rbxmx");
+var distDirectory = path4.dirname(fileURLToPath(import.meta.url));
+var source = path4.resolve(distDirectory, "..", "plugin", "Dominus.rbxmx");
 var destinationDirectory = getPluginDirectory();
-var destination = path3.join(destinationDirectory, "Dominus2.rbxmx");
-if (!fs3.existsSync(source)) {
+var destination = path4.join(destinationDirectory, "Dominus2.rbxmx");
+if (!fs4.existsSync(source)) {
   throw new Error(`Packaged plugin not found at ${source}. Run pnpm build:plugin first.`);
 }
-var template = fs3.readFileSync(source, "utf8");
+var template = fs4.readFileSync(source, "utf8");
 if (!template.includes(TOKEN_PLACEHOLDER)) {
   throw new Error("Packaged plugin template is missing its bridge token placeholder");
 }
 var personalizedPlugin = template.replaceAll(TOKEN_PLACEHOLDER, loadOrCreateBridgeToken());
-fs3.mkdirSync(destinationDirectory, { recursive: true });
-fs3.writeFileSync(destination, personalizedPlugin, "utf8");
+fs4.mkdirSync(destinationDirectory, { recursive: true });
+fs4.writeFileSync(destination, personalizedPlugin, "utf8");
 for (const obsoleteName of ["Dominus2.rbxm", "Dominus.rbxm", "Dominus.rbxmx"]) {
-  const obsoletePath = path3.join(destinationDirectory, obsoleteName);
-  if (obsoletePath !== destination) fs3.rmSync(obsoletePath, { force: true });
+  const obsoletePath = path4.join(destinationDirectory, obsoleteName);
+  if (obsoletePath !== destination) fs4.rmSync(obsoletePath, { force: true });
 }
 console.log(`Installed Dominus 2 Studio plugin to ${destination}`);
 console.log(
-  "Roblox Studio normally reloads Dominus 2 automatically. Restart Studio only if the toolbar does not reconnect."
+  "Dominus 2 authenticates automatically. Restart Studio only if the toolbar does not reconnect."
 );
+var bridge = await ensureBridgeDaemon(loadConfig().port);
+await bridge.stop();
+console.log("Dominus Studio bridge is running in the background.");
 //# sourceMappingURL=install-plugin.js.map
 //# sourceMappingURL=install-plugin.js.map