one/dist/cjs/daemon/ipc.js

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

var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
  for (var name in all)
    __defProp(target, name, { get: all[name], enumerable: !0 });
}, __copyProps = (to, from, except, desc) => {
  if (from && typeof from == "object" || typeof from == "function")
    for (let key of __getOwnPropNames(from))
      !__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: !0 }) : target,
  mod
)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), 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("node:net"), 1), fs = __toESM(require("node:fs"), 1), path = __toESM(require("node:path"), 1), os = __toESM(require("node:os"), 1), import_registry = require("./registry");
const 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();
  const filtered = readServerFiles().filter((s) => s.root !== server.root);
  filtered.push(server), fs.writeFileSync(SERVERS_FILE, JSON.stringify(filtered, null, 2));
}
function removeServerFile(root) {
  const filtered = readServerFiles().filter((s) => 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();
  const server = net.createServer((socket) => {
    let buffer = "";
    socket.on("data", (data) => {
      buffer += data.toString();
      const lines = buffer.split(`
`);
      buffer = lines.pop() || "";
      for (const line of lines)
        if (line.trim())
          try {
            const message = JSON.parse(line), response = handleMessage(
              state,
              message,
              onServerRegistered,
              onServerUnregistered
            );
            socket.write(JSON.stringify(response) + `
`);
          } catch (err) {
            const errResponse = {
              type: "error",
              message: err instanceof Error ? err.message : "Unknown error"
            };
            socket.write(JSON.stringify(errResponse) + `
`);
          }
    }), socket.on("error", (err) => {
      console.error("[daemon] IPC socket error:", err.message);
    });
  });
  return server.listen(SOCKET_PATH, () => {
    fs.chmodSync(SOCKET_PATH, 384);
  }), server;
}
function handleMessage(state, message, onServerRegistered, onServerUnregistered) {
  switch (message.type) {
    case "register": {
      const registration = (0, import_registry.registerServer)(state, {
        port: message.port,
        bundleId: message.bundleId,
        root: message.root
      });
      return onServerRegistered?.(registration.id), { type: "registered", id: registration.id };
    }
    case "unregister":
      return (0, import_registry.unregisterServer)(state, message.id), onServerUnregistered?.(message.id), { type: "unregistered" };
    case "route":
      return (0, import_registry.findServerById)(state, message.serverId) ? ((0, import_registry.setRoute)(state, message.bundleId, message.serverId), { type: "routed" }) : { type: "error", message: `Server not found: ${message.serverId}` };
    case "route-clear":
      return (0, import_registry.clearRoute)(state, message.bundleId), { 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":
      return (0, import_registry.touchServer)(state, message.id) ? { type: "touched" } : { type: "error", message: `Server not found: ${message.id}` };
    case "get-last-active":
      return { type: "last-active", server: (0, import_registry.getLastActiveServer)(state) };
    default:
      return { type: "error", message: "Unknown message type" };
  }
}
async function isDaemonRunning() {
  return new Promise((resolve) => {
    if (!fs.existsSync(SOCKET_PATH)) {
      resolve(!1);
      return;
    }
    const client = net.connect(SOCKET_PATH), timeout = setTimeout(() => {
      client.destroy(), resolve(!1);
    }, 1e3);
    client.on("connect", () => {
      clearTimeout(timeout), client.write(JSON.stringify({ type: "ping" }) + `
`);
    }), client.on("data", (data) => {
      clearTimeout(timeout);
      try {
        const response = JSON.parse(data.toString().trim());
        resolve(response.type === "pong");
      } catch {
        resolve(!1);
      }
      client.destroy();
    }), client.on("error", () => {
      clearTimeout(timeout), resolve(!1);
    });
  });
}
async function sendIPCMessage(message) {
  return new Promise((resolve, reject) => {
    const client = net.connect(SOCKET_PATH);
    let buffer = "";
    const timeout = setTimeout(() => {
      client.destroy(), reject(new Error("IPC timeout"));
    }, 5e3);
    client.on("connect", () => {
      client.write(JSON.stringify(message) + `
`);
    }), client.on("data", (data) => {
      buffer += data.toString();
      const lines = buffer.split(`
`);
      buffer = lines.pop() || "";
      for (const line of lines)
        if (line.trim())
          try {
            clearTimeout(timeout);
            const response = JSON.parse(line);
            client.destroy(), resolve(response);
            return;
          } catch {
          }
    }), client.on("error", (err) => {
      clearTimeout(timeout), reject(err);
    });
  });
}
async function registerWithDaemon(opts) {
  const 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() {
  const 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) {
  const 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) {
  const response = await sendIPCMessage({ type: "touch", id });
  if (response.type === "error")
    throw new Error(response.message);
}
async function getLastActiveDaemonServer() {
  const 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.js.map