one
Version:
One is a new React Framework that makes Vite serve both native and web.
286 lines • 9.21 kB
JavaScript
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.cjs");
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");
}