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

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

import * as net from "net";
import * as fs from "fs";
import * as path from "path";
import * as os from "os";
import { registerServer, unregisterServer, getAllServers, getAllRoutes, setRoute, clearRoute, findServerById, touchServer, getLastActiveServer } from "./registry.native.js";
function _instanceof(left, right) {
  return right != null && typeof Symbol < "u" && right[Symbol.hasInstance] ? !!right[Symbol.hasInstance](left) : left instanceof right;
}
var SOCKET_DIR = path.join(os.homedir(), ".one"),
  SOCKET_PATH = path.join(SOCKET_DIR, "daemon.sock"),
  SERVERS_FILE = path.join(SOCKET_DIR, "servers.json");
function getSocketPath() {
  return SOCKET_PATH;
}
function getServersFilePath() {
  return SERVERS_FILE;
}
function ensureSocketDir() {
  fs.existsSync(SOCKET_DIR) || fs.mkdirSync(SOCKET_DIR, {
    recursive: !0
  });
}
function writeServerFile(server) {
  ensureSocketDir();
  var servers = readServerFiles(),
    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(),
    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 {}
  return [];
}
function cleanupSocket() {
  try {
    fs.existsSync(SOCKET_PATH) && fs.unlinkSync(SOCKET_PATH);
  } catch {}
}
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(`
`);
      buffer = lines.pop() || "";
      var _iteratorNormalCompletion = !0,
        _didIteratorError = !1,
        _iteratorError = void 0;
      try {
        for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
          var line = _step.value;
          if (line.trim()) try {
            var message = JSON.parse(line),
              response = handleMessage(state, message, onServerRegistered, onServerUnregistered);
            socket.write(JSON.stringify(response) + `
`);
          } catch (err) {
            var errResponse = {
              type: "error",
              message: _instanceof(err, Error) ? err.message : "Unknown error"
            };
            socket.write(JSON.stringify(errResponse) + `
`);
          }
        }
      } catch (err) {
        _didIteratorError = !0, _iteratorError = err;
      } finally {
        try {
          !_iteratorNormalCompletion && _iterator.return != null && _iterator.return();
        } finally {
          if (_didIteratorError) throw _iteratorError;
        }
      }
    }), socket.on("error", function (err) {
      console.error("[daemon] IPC socket error:", err.message);
    });
  });
  return server.listen(SOCKET_PATH, function () {
    fs.chmodSync(SOCKET_PATH, 384);
  }), server;
}
function handleMessage(state, message, onServerRegistered, onServerUnregistered) {
  switch (message.type) {
    case "register":
      {
        var registration = registerServer(state, {
          port: message.port,
          bundleId: message.bundleId,
          root: message.root
        });
        return onServerRegistered?.(registration.id), {
          type: "registered",
          id: registration.id
        };
      }
    case "unregister":
      return unregisterServer(state, message.id), onServerUnregistered?.(message.id), {
        type: "unregistered"
      };
    case "route":
      {
        var server = findServerById(state, message.serverId);
        return server ? (setRoute(state, message.bundleId, message.serverId), {
          type: "routed"
        }) : {
          type: "error",
          message: `Server not found: ${message.serverId}`
        };
      }
    case "route-clear":
      return clearRoute(state, message.bundleId), {
        type: "routed"
      };
    case "status":
      return {
        type: "status",
        servers: getAllServers(state),
        routes: getAllRoutes(state)
      };
    case "ping":
      return {
        type: "pong"
      };
    case "touch":
      {
        var touched = touchServer(state, message.id);
        return touched ? {
          type: "touched"
        } : {
          type: "error",
          message: `Server not found: ${message.id}`
        };
      }
    case "get-last-active":
      {
        var server1 = 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(!1);
      return;
    }
    var client = net.connect(SOCKET_PATH),
      timeout = setTimeout(function () {
        client.destroy(), resolve(!1);
      }, 1e3);
    client.on("connect", function () {
      clearTimeout(timeout), client.write(JSON.stringify({
        type: "ping"
      }) + `
`);
    }), client.on("data", function (data) {
      clearTimeout(timeout);
      try {
        var response = JSON.parse(data.toString().trim());
        resolve(response.type === "pong");
      } catch {
        resolve(!1);
      }
      client.destroy();
    }), client.on("error", function () {
      clearTimeout(timeout), resolve(!1);
    });
  });
}
async function sendIPCMessage(message) {
  return new Promise(function (resolve, reject) {
    var client = net.connect(SOCKET_PATH),
      buffer = "",
      timeout = setTimeout(function () {
        client.destroy(), reject(new Error("IPC timeout"));
      }, 5e3);
    client.on("connect", function () {
      client.write(JSON.stringify(message) + `
`);
    }), client.on("data", function (data) {
      buffer += data.toString();
      var lines = buffer.split(`
`);
      buffer = lines.pop() || "";
      var _iteratorNormalCompletion = !0,
        _didIteratorError = !1,
        _iteratorError = void 0;
      try {
        for (var _iterator = lines[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = !0) {
          var line = _step.value;
          if (line.trim()) try {
            clearTimeout(timeout);
            var response = JSON.parse(line);
            client.destroy(), resolve(response);
            return;
          } catch {}
        }
      } catch (err) {
        _didIteratorError = !0, _iteratorError = err;
      } finally {
        try {
          !_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;
  throw response.type === "error" ? new Error(response.message) : 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");
}
export { cleanupSocket, clearDaemonRoute, createIPCServer, ensureSocketDir, getDaemonStatus, getLastActiveDaemonServer, getServersFilePath, getSocketPath, isDaemonRunning, readServerFiles, registerWithDaemon, removeServerFile, sendIPCMessage, setDaemonRoute, touchDaemonServer, unregisterFromDaemon, writeServerFile };
//# sourceMappingURL=ipc.native.js.map