@llblab/pi-actors 0.20.2 → 0.22.0

package/scripts/locker.mjs

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import {
   appendFileSync,
   existsSync,
@@ -7,8 +9,8 @@ import {
   rmSync,
   writeFileSync,
 } from "node:fs";
+import { createServer } from "node:net";
 import { dirname, join, resolve } from "node:path";
-import { spawnSync } from "node:child_process";
 import readline from "node:readline";
 
 function parseArgs(argv) {
@@ -49,6 +51,21 @@ function writeJson(path, value) {
   mkdirSync(dirname(path), { recursive: true });
   writeFileSync(path, `${JSON.stringify(value, null, 2)}\n`, "utf8");
 }
+function getControlEndpoint() {
+  if (process.platform !== "win32") return { path: controlPath, type: "fifo" };
+  const hash = createHash("sha256")
+    .update(resolve(stateDir))
+    .digest("hex")
+    .slice(0, 20);
+  return { path: `\\\\.\\pipe\\pi-actors-locker-${hash}`, type: "named-pipe" };
+}
+function writeControlEndpoint(endpoint) {
+  writeJson(join(stateDir, "control.json"), endpoint);
+  const runPath = join(stateDir, "run.json");
+  const run = readJson(runPath, undefined);
+  if (run && typeof run === "object")
+    writeJson(runPath, { ...run, control: endpoint });
+}
 function journal(event, data = {}) {
   appendFileSync(
     journalPath,
@@ -205,9 +222,19 @@ function handle(message) {
     if (!resource) throw new Error("lock.renew body.resource is required");
     const current = locks[resource];
     if (!current) {
-      outbox("lock.denied", `Lock renew denied ${resource}`, { resource, owner, reason: "missing" }, "warning");
+      outbox(
+        "lock.denied",
+        `Lock renew denied ${resource}`,
+        { resource, owner, reason: "missing" },
+        "warning",
+      );
     } else if (current.owner !== owner) {
-      outbox("lock.denied", `Lock renew denied ${resource}`, { resource, owner, current }, "warning");
+      outbox(
+        "lock.denied",
+        `Lock renew denied ${resource}`,
+        { resource, owner, current },
+        "warning",
+      );
     } else {
       locks[resource] = { ...current, expiresAt: now() + leaseMs };
       outbox("lock.renewed", `Lock renewed ${resource}`, { resource, owner });
@@ -222,8 +249,15 @@ function handle(message) {
     outbox("lock.released", `Lock released ${resource}`, { resource });
     return;
   }
-  if (type === "lock.complete" || type === "lock.fail" || type === "coord.complete" || type === "coord.fail") {
-    const eventType = type.startsWith("coord.") ? type.replace("coord.", "lock.") : type;
+  if (
+    type === "lock.complete" ||
+    type === "lock.fail" ||
+    type === "coord.complete" ||
+    type === "coord.fail"
+  ) {
+    const eventType = type.startsWith("coord.")
+      ? type.replace("coord.", "lock.")
+      : type;
     journal(eventType, body);
     outbox(
       eventType,
@@ -244,30 +278,55 @@ if (mode === "snapshot") {
   process.exit(0);
 }
 
-if (!existsSync(controlPath)) {
-  const result = spawnSync("mkfifo", [controlPath]);
-  if (result.status !== 0)
-    throw new Error(`mkfifo failed: ${result.stderr?.toString?.() ?? ""}`);
+function handleLine(line) {
+  const message = normalizeMessage(line);
+  if (!message) return;
+  try {
+    handle(message);
+  } catch (error) {
+    const text = error instanceof Error ? error.message : String(error);
+    journal("lock.error", { error: text });
+    outbox("lock.error", text, { error: text }, "error");
+  }
 }
-writeJson(queuePath, readJson(queuePath, { items: [] }));
-writeJson(locksPath, cleanExpiredLocks(readJson(locksPath, {})));
-journal("lock.started", { leaseMs });
-outbox("lock.started", "Locker ready", { leaseMs });
 
-while (true) {
-  const stream = await import("node:fs").then((fs) =>
-    fs.createReadStream(controlPath, { encoding: "utf8" }),
-  );
-  const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
-  for await (const line of rl) {
-    const message = normalizeMessage(line);
-    if (!message) continue;
-    try {
-      handle(message);
-    } catch (error) {
-      const text = error instanceof Error ? error.message : String(error);
-      journal("lock.error", { error: text });
-      outbox("lock.error", text, { error: text }, "error");
-    }
+async function serveFifo(endpoint) {
+  if (!existsSync(endpoint.path)) {
+    const result = spawnSync("mkfifo", [endpoint.path]);
+    if (result.status !== 0)
+      throw new Error(`mkfifo failed: ${result.stderr?.toString?.() ?? ""}`);
   }
+  writeControlEndpoint(endpoint);
+  while (true) {
+    const stream = await import("node:fs").then((fs) =>
+      fs.createReadStream(endpoint.path, { encoding: "utf8" }),
+    );
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) handleLine(line);
+  }
+}
+
+async function serveNamedPipe(endpoint) {
+  rmSync(endpoint.path, { force: true });
+  const server = createServer((socket) => {
+    const rl = readline.createInterface({ input: socket, crlfDelay: Infinity });
+    rl.on("line", handleLine);
+  });
+  await new Promise((resolveReady, rejectReady) => {
+    server.once("error", rejectReady);
+    server.listen(endpoint.path, () => {
+      server.off("error", rejectReady);
+      writeControlEndpoint(endpoint);
+      resolveReady();
+    });
+  });
+  await new Promise(() => {});
 }
+
+const endpoint = getControlEndpoint();
+writeJson(queuePath, readJson(queuePath, { items: [] }));
+writeJson(locksPath, cleanExpiredLocks(readJson(locksPath, {})));
+journal("lock.started", { leaseMs, control: endpoint.type });
+outbox("lock.started", "Locker ready", { leaseMs, control: endpoint.type });
+if (endpoint.type === "named-pipe") await serveNamedPipe(endpoint);
+else await serveFifo(endpoint);