index.js

const fs = require("fs");
const path = require("path");
const WebSocket = require("ws");

const websocketUrl = "ws://127.0.0.1:18714";
const reconnectDelayMs = 2000;

let wsClient;
let reconnectTimeoutId;
let controller;
let preferenceMessagePort;

let actionId = 0;
let hasShownClampWarning = false;

function isClientConnected() {
  return wsClient?.readyState === WebSocket.OPEN;
}

function scheduleReconnect() {
  if (reconnectTimeoutId) return;

  reconnectTimeoutId = setTimeout(() => {
    reconnectTimeoutId = undefined;
    if (!isClientConnected()) {
      connectToDeej();
    }
  }, reconnectDelayMs);
}

function connectToDeej() {
  try {
    wsClient?.removeAllListeners?.();
    wsClient?.terminate?.();
  } catch (error) {
    console.error("Failed to reset previous deej connection", error);
  }

  const client = new WebSocket(websocketUrl);
  wsClient = client;

  client.on("open", () => {
    console.log(`Connected to deej websocket at ${websocketUrl}`);
    hasShownClampWarning = false;
    notifyStatusChange();
  });

  client.on("message", handleWebsocketMessage);

  client.on("close", () => {
    if (wsClient === client) {
      wsClient = undefined;
      notifyStatusChange();
      scheduleReconnect();
    }
  });

  client.on("error", (error) => {
    console.error("deej websocket error", error);
  });
}

exports.loadPackage = async function (gridController, _persistedData) {
  controller = gridController;
  hasShownClampWarning = false;

  const actionIconSvg = fs.readFileSync(
    path.resolve(__dirname, "deej-logo-black.svg"),
    { encoding: "utf-8" },
  );

  function createAction(overrides) {
    gridController.sendMessageToEditor({
      type: "add-action",
      info: {
        actionId: actionId++,
        rendering: "standard",
        category: "deej",
        color: "#00a827",
        icon: actionIconSvg,
        blockIcon: actionIconSvg,
        selectable: true,
        movable: true,
        hideIcon: false,
        type: "single",
        toggleable: true,
        ...overrides,
      },
    });
  }

  createAction({
    short: "xdeejcv",
    displayName: "Channel Value",
    defaultLua:
      'gps("package-deej", 0, math.floor(self:get_auto_value() * 1023))',
    actionComponent: "deej-channel-action",
  });

  connectToDeej();
};

exports.unloadPackage = async function () {
  while (--actionId >= 0) {
    controller.sendMessageToEditor({
      type: "remove-action",
      actionId,
    });
  }

  if (reconnectTimeoutId) {
    clearTimeout(reconnectTimeoutId);
    reconnectTimeoutId = undefined;
  }

  try {
    wsClient?.removeAllListeners?.();
    wsClient?.terminate?.();
  } catch (error) {
    console.error("Failed to close deej websocket", error);
  }

  wsClient = undefined;
  preferenceMessagePort?.close();
  preferenceMessagePort = undefined;
};

exports.addMessagePort = async function (port, senderId) {
  if (senderId === "preferences") {
    preferenceMessagePort?.close();
    preferenceMessagePort = port;
    port.on("close", () => {
      preferenceMessagePort = undefined;
    });
    port.start();
    notifyStatusChange();
  }
};

exports.sendMessage = async function (args) {
  console.log({ args });
  if (!Array.isArray(args)) return;

  if (!isClientConnected()) {
    console.log("deej websocket not connected");
    controller.sendMessageToEditor({
      type: "show-message",
      message: "Unable to reach deej over WebSocket. Is deej running?",
      messageType: "fail",
    });
    return;
  }

  const channel = Number(args[0]);
  const value = Number(args[1]);
  if (!Number.isFinite(channel) || !Number.isFinite(value)) {
    controller.sendMessageToEditor({
      type: "show-message",
      message: "Channel and value must resolve to numeric values.",
      messageType: "fail",
    });
    return;
  }

  const roundedValue = Math.round(value);
  const clampedValue = Math.max(0, Math.min(1023, roundedValue));
  if (clampedValue !== roundedValue && !hasShownClampWarning) {
    controller.sendMessageToEditor({
      type: "show-message",
      message: "Value was clamped to the 0-1023 range for deej.",
      messageType: "alert",
    });
    hasShownClampWarning = true;
  }

  wsClient?.send(
    JSON.stringify({
      event: "set-channel",
      channel,
      value: clampedValue,
    }),
  );
};

function handleWebsocketMessage(message) {
  try {
    const data = JSON.parse(message);
    console.log({ data });
    if (data.type === "execute-code") {
      controller.sendMessageToEditor({
        type: "execute-lua-script",
        script: data.script,
        targetDx: data.targetDx,
        targetDy: data.targetDy,
      });
    }
  } catch (error) {
    console.error("Failed to parse message from deej", {
      error,
      message: String(message),
    });
  }
}

function notifyStatusChange() {
  preferenceMessagePort?.postMessage({
    type: "clientStatus",
    clientConnected: isClientConnected(),
  });
}