one/dist/esm/daemon/ipc.mjs

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

import * as net from "node:net";
import * as fs from "node:fs";
import * as path from "node:path";
import * as os from "node:os";
import { registerServer, unregisterServer, getAllServers, getAllRoutes, setRoute, clearRoute, findServerById, touchServer, getLastActiveServer } from "./registry.mjs";
const SOCKET_DIR = path.join(os.homedir(), ".one");
const SOCKET_PATH = path.join(SOCKET_DIR, "daemon.sock");
const 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();
  const servers = readServerFiles();
  const filtered = servers.filter(s => s.root !== server.root);
  filtered.push(server);
  fs.writeFileSync(SERVERS_FILE, JSON.stringify(filtered, null, 2));
}
function removeServerFile(root) {
  const servers = readServerFiles();
  const filtered = servers.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 {
    if (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("\n");
      buffer = lines.pop() || "";
      for (const line of lines) {
        if (!line.trim()) continue;
        try {
          const message = JSON.parse(line);
          const response = handleMessage(state, message, onServerRegistered, onServerUnregistered);
          socket.write(JSON.stringify(response) + "\n");
        } catch (err) {
          const errResponse = {
            type: "error",
            message: err instanceof Error ? err.message : "Unknown error"
          };
          socket.write(JSON.stringify(errResponse) + "\n");
        }
      }
    });
    socket.on("error", err => {
      console.error("[daemon] IPC socket error:", err.message);
    });
  });
  server.listen(SOCKET_PATH, () => {
    fs.chmodSync(SOCKET_PATH, 384);
  });
  return server;
}
function handleMessage(state, message, onServerRegistered, onServerUnregistered) {
  switch (message.type) {
    case "register":
      {
        const registration = registerServer(state, {
          port: message.port,
          bundleId: message.bundleId,
          root: message.root
        });
        onServerRegistered?.(registration.id);
        return {
          type: "registered",
          id: registration.id
        };
      }
    case "unregister":
      {
        unregisterServer(state, message.id);
        onServerUnregistered?.(message.id);
        return {
          type: "unregistered"
        };
      }
    case "route":
      {
        const server = findServerById(state, message.serverId);
        if (!server) {
          return {
            type: "error",
            message: `Server not found: ${message.serverId}`
          };
        }
        setRoute(state, message.bundleId, message.serverId);
        return {
          type: "routed"
        };
      }
    case "route-clear":
      {
        clearRoute(state, message.bundleId);
        return {
          type: "routed"
        };
      }
    case "status":
      {
        return {
          type: "status",
          servers: getAllServers(state),
          routes: getAllRoutes(state)
        };
      }
    case "ping":
      {
        return {
          type: "pong"
        };
      }
    case "touch":
      {
        const touched = touchServer(state, message.id);
        if (!touched) {
          return {
            type: "error",
            message: `Server not found: ${message.id}`
          };
        }
        return {
          type: "touched"
        };
      }
    case "get-last-active":
      {
        const server = getLastActiveServer(state);
        return {
          type: "last-active",
          server
        };
      }
    default:
      {
        return {
          type: "error",
          message: `Unknown message type`
        };
      }
  }
}
async function isDaemonRunning() {
  return new Promise(resolve => {
    if (!fs.existsSync(SOCKET_PATH)) {
      resolve(false);
      return;
    }
    const client = net.connect(SOCKET_PATH);
    const timeout = setTimeout(() => {
      client.destroy();
      resolve(false);
    }, 1e3);
    client.on("connect", () => {
      clearTimeout(timeout);
      client.write(JSON.stringify({
        type: "ping"
      }) + "\n");
    });
    client.on("data", data => {
      clearTimeout(timeout);
      try {
        const response = JSON.parse(data.toString().trim());
        resolve(response.type === "pong");
      } catch {
        resolve(false);
      }
      client.destroy();
    });
    client.on("error", () => {
      clearTimeout(timeout);
      resolve(false);
    });
  });
}
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) + "\n");
    });
    client.on("data", data => {
      buffer += data.toString();
      const lines = buffer.split("\n");
      buffer = lines.pop() || "";
      for (const line of lines) {
        if (!line.trim()) continue;
        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;
  }
  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() {
  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");
}
export { cleanupSocket, clearDaemonRoute, createIPCServer, ensureSocketDir, getDaemonStatus, getLastActiveDaemonServer, getServersFilePath, getSocketPath, isDaemonRunning, readServerFiles, registerWithDaemon, removeServerFile, sendIPCMessage, setDaemonRoute, touchDaemonServer, unregisterFromDaemon, writeServerFile };
//# sourceMappingURL=ipc.mjs.map