@unlinearity/cli-wechat-bridge 1.0.4 → 1.0.6

package/dist/daemon/daemon-link.js

@@ -0,0 +1,175 @@
+import crypto from "node:crypto";
+import fs from "node:fs";
+import net from "node:net";
+import { DAEMON_ENDPOINT_FILE, ensureChannelDataDir, } from "../wechat/channel-config.js";
+export const DAEMON_PROTOCOL_VERSION = 1;
+function normalizeDaemonEndpoint(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        return null;
+    }
+    const record = value;
+    if (typeof record.protocolVersion !== "number" ||
+        typeof record.pid !== "number" ||
+        typeof record.port !== "number" ||
+        typeof record.token !== "string" ||
+        typeof record.cwd !== "string" ||
+        typeof record.startedAt !== "string") {
+        return null;
+    }
+    return {
+        protocolVersion: record.protocolVersion,
+        pid: record.pid,
+        port: record.port,
+        token: record.token,
+        cwd: record.cwd,
+        startedAt: record.startedAt,
+    };
+}
+export function buildDaemonToken() {
+    return crypto.randomBytes(18).toString("hex");
+}
+export function writeDaemonEndpoint(endpoint) {
+    ensureChannelDataDir();
+    fs.writeFileSync(DAEMON_ENDPOINT_FILE, JSON.stringify({
+        ...endpoint,
+        protocolVersion: DAEMON_PROTOCOL_VERSION,
+    }, null, 2), "utf8");
+}
+export function readDaemonEndpoint() {
+    try {
+        if (!fs.existsSync(DAEMON_ENDPOINT_FILE)) {
+            return null;
+        }
+        return normalizeDaemonEndpoint(JSON.parse(fs.readFileSync(DAEMON_ENDPOINT_FILE, "utf8")));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearDaemonEndpoint(pid = process.pid) {
+    try {
+        const endpoint = readDaemonEndpoint();
+        if (!endpoint || endpoint.pid === pid) {
+            fs.rmSync(DAEMON_ENDPOINT_FILE, { force: true });
+        }
+    }
+    catch {
+        // Best effort cleanup.
+    }
+}
+export function isPidAlive(pid) {
+    if (!Number.isInteger(pid) || pid <= 0) {
+        return false;
+    }
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function sendDaemonResponse(socket, id, response) {
+    if (socket.destroyed || socket.writableEnded) {
+        return false;
+    }
+    try {
+        return socket.write(`${JSON.stringify({ id, response })}\n`);
+    }
+    catch {
+        return false;
+    }
+}
+export function attachDaemonRequestListener(socket, onRequest) {
+    let buffer = "";
+    const onData = (chunk) => {
+        buffer += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+        while (true) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex < 0) {
+                return;
+            }
+            const line = buffer.slice(0, newlineIndex).trim();
+            buffer = buffer.slice(newlineIndex + 1);
+            if (!line) {
+                continue;
+            }
+            try {
+                onRequest(JSON.parse(line));
+            }
+            catch {
+                // Ignore malformed daemon IPC frames.
+            }
+        }
+    };
+    socket.setEncoding("utf8");
+    socket.on("data", onData);
+    return () => {
+        socket.off("data", onData);
+    };
+}
+export async function sendDaemonRequest(endpoint, payload, options = {}) {
+    const timeoutMs = options.timeoutMs ?? 2_000;
+    const id = crypto.randomUUID();
+    return await new Promise((resolve) => {
+        const socket = net.connect({
+            host: "127.0.0.1",
+            port: endpoint.port,
+        });
+        let buffer = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            finish({ ok: false, error: "Timed out waiting for daemon response." });
+        }, timeoutMs);
+        const finish = (response) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            clearTimeout(timer);
+            socket.destroy();
+            resolve(response);
+        };
+        socket.setEncoding("utf8");
+        socket.once("connect", () => {
+            socket.write(`${JSON.stringify({
+                id,
+                token: endpoint.token,
+                payload,
+            })}\n`);
+        });
+        socket.on("data", (chunk) => {
+            buffer += chunk;
+            while (true) {
+                const newlineIndex = buffer.indexOf("\n");
+                if (newlineIndex < 0) {
+                    return;
+                }
+                const line = buffer.slice(0, newlineIndex).trim();
+                buffer = buffer.slice(newlineIndex + 1);
+                if (!line) {
+                    continue;
+                }
+                try {
+                    const frame = JSON.parse(line);
+                    if (frame.id === id) {
+                        finish(frame.response);
+                    }
+                }
+                catch {
+                    // Ignore malformed daemon IPC frames.
+                }
+            }
+        });
+        socket.once("error", () => {
+            finish({ ok: false, error: "Daemon endpoint is not reachable." });
+        });
+    });
+}
+export async function isDaemonEndpointAlive(endpoint, options = {}) {
+    if (!isPidAlive(endpoint.pid)) {
+        return false;
+    }
+    const response = await sendDaemonRequest(endpoint, { command: "status" }, options);
+    return response.ok;
+}