one/dist/cjs/daemon/ipc.native.js

One is a new React Framework that makes Vite serve both native and web.

"use strict";

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
  value: mod,
  enumerable: true
}) : target, mod));
var __toCommonJS = mod => __copyProps(__defProp({}, "__esModule", {
  value: true
}), mod);
var ipc_exports = {};
__export(ipc_exports, {
  cleanupSocket: () => cleanupSocket,
  clearDaemonRoute: () => clearDaemonRoute,
  createIPCServer: () => createIPCServer,
  ensureSocketDir: () => ensureSocketDir,
  getDaemonStatus: () => getDaemonStatus,
  getLastActiveDaemonServer: () => getLastActiveDaemonServer,
  getServersFilePath: () => getServersFilePath,
  getSocketPath: () => getSocketPath,
  isDaemonRunning: () => isDaemonRunning,
  readServerFiles: () => readServerFiles,
  registerWithDaemon: () => registerWithDaemon,
  removeServerFile: () => removeServerFile,
  sendIPCMessage: () => sendIPCMessage,
  setDaemonRoute: () => setDaemonRoute,
  touchDaemonServer: () => touchDaemonServer,
  unregisterFromDaemon: () => unregisterFromDaemon,
  writeServerFile: () => writeServerFile
});
module.exports = __toCommonJS(ipc_exports);
var net = __toESM(require("net"), 1);
var fs = __toESM(require("fs"), 1);
var path = __toESM(require("path"), 1);
var os = __toESM(require("os"), 1);
var import_registry = require("./registry.native.js");
function _instanceof(left, right) {
  if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) {
    return !!right[Symbol.hasInstance](left);
  } else {
    return left instanceof right;
  }
}
var SOCKET_DIR = path.join(os.homedir(), ".one");
var SOCKET_PATH = path.join(SOCKET_DIR, "daemon.sock");
var SERVERS_FILE = path.join(SOCKET_DIR, "servers.json");
function getSocketPath() {
  return SOCKET_PATH;
}
function getServersFilePath() {
  return SERVERS_FILE;
}
function ensureSocketDir() {
  if (!fs.existsSync(SOCKET_DIR)) {
    fs.mkdirSync(SOCKET_DIR, {
      recursive: true
    });
  }
}
function writeServerFile(server) {
  ensureSocketDir();
  var servers = readServerFiles();
  var filtered = servers.filter(function (s) {
    return s.root !== server.root;
  });
  filtered.push(server);
  fs.writeFileSync(SERVERS_FILE, JSON.stringify(filtered, null, 2));
}
function removeServerFile(root) {
  var servers = readServerFiles();
  var filtered = servers.filter(function (s) {
    return s.root !== root;
  });
  fs.writeFileSync(SERVERS_FILE, JSON.stringify(filtered, null, 2));
}
function readServerFiles() {
  try {
    if (fs.existsSync(SERVERS_FILE)) {
      return JSON.parse(fs.readFileSync(SERVERS_FILE, "utf-8"));
    }
  } catch (unused) {}
  return [];
}
function cleanupSocket() {
  try {
    if (fs.existsSync(SOCKET_PATH)) {
      fs.unlinkSync(SOCKET_PATH);
    }
  } catch (unused) {}
}
function createIPCServer(state, onServerRegistered, onServerUnregistered) {
  ensureSocketDir();
  cleanupSocket();
  var server = net.createServer(function (socket) {
    var buffer = "";
    socket.on("data", function (data) {
      buffer += data.toString();
      var lines = buffer.split("\n");
      buffer = lines.pop() || "";
      var _iteratorNormalCompletion = true,
        _didIteratorError = false,
        _iteratorError = void 0;
      try {
        for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var line = _step.value;
          if (!line.trim()) continue;
          try {
            var message = JSON.parse(line);
            var response = handleMessage(state, message, onServerRegistered, onServerUnregistered);
            socket.write(JSON.stringify(response) + "\n");
          } catch (err) {
            var errResponse = {
              type: "error",
              message: _instanceof(err, Error) ? err.message : "Unknown error"
            };
            socket.write(JSON.stringify(errResponse) + "\n");
          }
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    });
    socket.on("error", function (err) {
      console.error("[daemon] IPC socket error:", err.message);
    });
  });
  server.listen(SOCKET_PATH, function () {
    fs.chmodSync(SOCKET_PATH, 384);
  });
  return server;
}
function handleMessage(state, message, onServerRegistered, onServerUnregistered) {
  switch (message.type) {
    case "register":
      {
        var registration = (0, import_registry.registerServer)(state, {
          port: message.port,
          bundleId: message.bundleId,
          root: message.root
        });
        onServerRegistered === null || onServerRegistered === void 0 ? void 0 : onServerRegistered(registration.id);
        return {
          type: "registered",
          id: registration.id
        };
      }
    case "unregister":
      {
        (0, import_registry.unregisterServer)(state, message.id);
        onServerUnregistered === null || onServerUnregistered === void 0 ? void 0 : onServerUnregistered(message.id);
        return {
          type: "unregistered"
        };
      }
    case "route":
      {
        var server = (0, import_registry.findServerById)(state, message.serverId);
        if (!server) {
          return {
            type: "error",
            message: `Server not found: ${message.serverId}`
          };
        }
        (0, import_registry.setRoute)(state, message.bundleId, message.serverId);
        return {
          type: "routed"
        };
      }
    case "route-clear":
      {
        (0, import_registry.clearRoute)(state, message.bundleId);
        return {
          type: "routed"
        };
      }
    case "status":
      {
        return {
          type: "status",
          servers: (0, import_registry.getAllServers)(state),
          routes: (0, import_registry.getAllRoutes)(state)
        };
      }
    case "ping":
      {
        return {
          type: "pong"
        };
      }
    case "touch":
      {
        var touched = (0, import_registry.touchServer)(state, message.id);
        if (!touched) {
          return {
            type: "error",
            message: `Server not found: ${message.id}`
          };
        }
        return {
          type: "touched"
        };
      }
    case "get-last-active":
      {
        var server1 = (0, import_registry.getLastActiveServer)(state);
        return {
          type: "last-active",
          server: server1
        };
      }
    default:
      {
        return {
          type: "error",
          message: `Unknown message type`
        };
      }
  }
}
async function isDaemonRunning() {
  return new Promise(function (resolve) {
    if (!fs.existsSync(SOCKET_PATH)) {
      resolve(false);
      return;
    }
    var client = net.connect(SOCKET_PATH);
    var timeout = setTimeout(function () {
      client.destroy();
      resolve(false);
    }, 1e3);
    client.on("connect", function () {
      clearTimeout(timeout);
      client.write(JSON.stringify({
        type: "ping"
      }) + "\n");
    });
    client.on("data", function (data) {
      clearTimeout(timeout);
      try {
        var response = JSON.parse(data.toString().trim());
        resolve(response.type === "pong");
      } catch (unused) {
        resolve(false);
      }
      client.destroy();
    });
    client.on("error", function () {
      clearTimeout(timeout);
      resolve(false);
    });
  });
}
async function sendIPCMessage(message) {
  return new Promise(function (resolve, reject) {
    var client = net.connect(SOCKET_PATH);
    var buffer = "";
    var timeout = setTimeout(function () {
      client.destroy();
      reject(new Error("IPC timeout"));
    }, 5e3);
    client.on("connect", function () {
      client.write(JSON.stringify(message) + "\n");
    });
    client.on("data", function (data) {
      buffer += data.toString();
      var lines = buffer.split("\n");
      buffer = lines.pop() || "";
      var _iteratorNormalCompletion = true,
        _didIteratorError = false,
        _iteratorError = void 0;
      try {
        for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
          var line = _step.value;
          if (!line.trim()) continue;
          try {
            clearTimeout(timeout);
            var response = JSON.parse(line);
            client.destroy();
            resolve(response);
            return;
          } catch (unused) {}
        }
      } catch (err) {
        _didIteratorError = true;
        _iteratorError = err;
      } finally {
        try {
          if (!_iteratorNormalCompletion && _iterator.return != null) {
            _iterator.return();
          }
        } finally {
          if (_didIteratorError) {
            throw _iteratorError;
          }
        }
      }
    });
    client.on("error", function (err) {
      clearTimeout(timeout);
      reject(err);
    });
  });
}
async function registerWithDaemon(opts) {
  var response = await sendIPCMessage({
    type: "register",
    ...opts
  });
  if (response.type === "registered") {
    return response.id;
  }
  if (response.type === "error") {
    throw new Error(response.message);
  }
  throw new Error("Unexpected response from daemon");
}
async function unregisterFromDaemon(id) {
  await sendIPCMessage({
    type: "unregister",
    id
  });
}
async function getDaemonStatus() {
  var response = await sendIPCMessage({
    type: "status"
  });
  if (response.type === "status") {
    return {
      servers: response.servers,
      routes: response.routes
    };
  }
  throw new Error("Failed to get daemon status");
}
async function setDaemonRoute(bundleId, serverId) {
  var response = await sendIPCMessage({
    type: "route",
    bundleId,
    serverId
  });
  if (response.type === "error") {
    throw new Error(response.message);
  }
}
async function clearDaemonRoute(bundleId) {
  await sendIPCMessage({
    type: "route-clear",
    bundleId
  });
}
async function touchDaemonServer(id) {
  var response = await sendIPCMessage({
    type: "touch",
    id
  });
  if (response.type === "error") {
    throw new Error(response.message);
  }
}
async function getLastActiveDaemonServer() {
  var response = await sendIPCMessage({
    type: "get-last-active"
  });
  if (response.type === "last-active") {
    return response.server;
  }
  throw new Error("Failed to get last active server");
}
//# sourceMappingURL=ipc.native.js.map