@llblab/pi-actors 0.23.0 → 0.24.0

package/scripts/locker.mjs

@@ -1,345 +1,33 @@
 #!/usr/bin/env node
 
 /**
- * Local coordination locker service.
+ * Local coordination locker service shim.
  *
- * This script owns a small file-backed lock/task state directory and exposes a
- * Unix-socket command surface for coordinators. It can serve live lock requests,
- * queue work items, hand out task leases, renew/release resource locks, and emit
- * compact snapshots for inspection.
- *
- * Keep it generic: no project policy, no recipe-specific prompts, and no actor
- * orchestration decisions belong in this layer.
+ * Runtime logic lives in lib/locker.ts and is compiled to dist/lib/locker.js
+ * for installed JS-only packages.
  */
 
-import { spawnSync } from "node:child_process";
-import { createHash } from "node:crypto";
-import {
-  appendFileSync,
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  rmSync,
-  writeFileSync,
-} from "node:fs";
-import { createServer } from "node:net";
-import { dirname, join, resolve } from "node:path";
-import readline from "node:readline";
-
-function parseArgs(argv) {
-  const args = { mode: "serve", stateDir: "", leaseMs: 600000, lines: 20 };
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index];
-    if (arg === "serve" || arg === "snapshot") args.mode = arg;
-    else if (arg === "--state-dir") args.stateDir = argv[++index] ?? "";
-    else if (arg === "--lease-ms")
-      args.leaseMs = Number(argv[++index] ?? args.leaseMs);
-    else if (arg === "--lines")
-      args.lines = Number(argv[++index] ?? args.lines);
-  }
-  if (!args.stateDir) throw new Error("--state-dir is required");
-  if (!Number.isFinite(args.leaseMs) || args.leaseMs <= 0)
-    args.leaseMs = 600000;
-  if (!Number.isFinite(args.lines) || args.lines <= 0) args.lines = 20;
-  return args;
-}
-
-const { mode, stateDir, leaseMs, lines } = parseArgs(process.argv.slice(2));
-const queuePath = join(stateDir, "queue.json");
-const locksPath = join(stateDir, "locks.json");
-const journalPath = join(stateDir, "journal.jsonl");
-const outboxPath = join(stateDir, "outbox.jsonl");
-const controlPath = join(stateDir, "control.fifo");
-mkdirSync(stateDir, { recursive: true });
-
-function readJson(path, fallback) {
-  if (!existsSync(path)) return fallback;
-  try {
-    return JSON.parse(readFileSync(path, "utf8"));
-  } catch {
-    return fallback;
-  }
-}
-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,
-    `${JSON.stringify({ event, ts: new Date().toISOString(), ...data })}\n`,
-  );
-}
-function outbox(type, summary, body = {}, level = "info") {
-  appendFileSync(
-    outboxPath,
-    `${JSON.stringify({ to: "coordinator", from: `run:${process.env.run_id ?? "locker"}`, type, event: type, summary, body, data: body, delivery: "followup", level, ts: new Date().toISOString() })}\n`,
-  );
-}
-function now() {
-  return Date.now();
-}
-function cleanExpiredLocks(locks) {
-  const current = now();
-  const kept = {};
-  for (const [key, lock] of Object.entries(locks)) {
-    if (Number(lock.expiresAt) > current) kept[key] = lock;
-    else journal("lock.expired", { resource: key, owner: lock.owner });
-  }
-  return kept;
-}
-function normalizeMessage(line) {
-  const trimmed = line.trim();
-  if (!trimmed) return undefined;
-  if (["stop", "quit", "exit", "cancel"].includes(trimmed.toLowerCase())) {
-    return { type: "control.stop", body: {} };
-  }
-  try {
-    return JSON.parse(trimmed);
-  } catch {
-    return { type: "lock.enqueue", body: { task: trimmed } };
-  }
-}
-function tailJournal(count) {
-  if (!existsSync(journalPath)) return [];
-  return readFileSync(journalPath, "utf8")
-    .trimEnd()
-    .split("\n")
-    .filter(Boolean)
-    .slice(-count)
-    .map((line) => {
-      try {
-        return JSON.parse(line);
-      } catch {
-        return { raw: line };
-      }
-    });
-}
-function printSnapshot() {
-  const locks = cleanExpiredLocks(readJson(locksPath, {}));
-  writeJson(locksPath, locks);
-  const queue = readJson(queuePath, { items: [] });
-  console.log(
-    JSON.stringify(
-      {
-        queueDepth: Array.isArray(queue.items) ? queue.items.length : 0,
-        queue,
-        locks,
-        journal: tailJournal(lines),
-      },
-      null,
-      2,
-    ),
-  );
-}
-function nextTask(queue, locks) {
-  const items = Array.isArray(queue.items) ? queue.items : [];
-  const index = items.findIndex((item) => {
-    const resources = Array.isArray(item.resources) ? item.resources : [];
-    return resources.every((resource) => !locks[resource]);
-  });
-  if (index < 0) return undefined;
-  return items.splice(index, 1)[0];
-}
-function handle(message) {
-  const type = message.type || message.event || "lock.enqueue";
-  const body =
-    message.body && typeof message.body === "object" ? message.body : message;
-  let queue = readJson(queuePath, { items: [] });
-  let locks = cleanExpiredLocks(readJson(locksPath, {}));
-  if (type === "control.stop" || type === "control.cancel") {
-    writeJson(locksPath, locks);
-    journal("control.stop", {});
-    outbox("lock.stopped", "Locker stopped", {
-      queueDepth: queue.items?.length ?? 0,
-    });
-    process.exit(0);
-  }
-  if (type === "lock.enqueue" || type === "coord.enqueue") {
-    const item = {
-      id: body.id || `task-${Date.now()}`,
-      task: body.task ?? body,
-      resources: body.resources ?? [],
-      enqueuedAt: new Date().toISOString(),
-    };
-    queue.items = [...(queue.items ?? []), item];
-    writeJson(queuePath, queue);
-    writeJson(locksPath, locks);
-    journal("lock.enqueued", { id: item.id, resources: item.resources });
-    outbox("lock.enqueued", `Queued task ${item.id}`, {
-      id: item.id,
-      queueDepth: queue.items.length,
-    });
-    return;
-  }
-  if (type === "lock.claim" || type === "coord.claim") {
-    const owner = body.owner || message.from || "worker";
-    const item = nextTask(queue, locks);
-    if (!item) {
-      writeJson(queuePath, queue);
-      writeJson(locksPath, locks);
-      outbox("lock.empty", "No claimable task", {
-        owner,
-        queueDepth: queue.items?.length ?? 0,
-      });
-      return;
-    }
-    for (const resource of item.resources ?? [])
-      locks[resource] = { owner, task: item.id, expiresAt: now() + leaseMs };
-    writeJson(queuePath, queue);
-    writeJson(locksPath, locks);
-    journal("lock.assigned", {
-      id: item.id,
-      owner,
-      resources: item.resources,
-    });
-    outbox("lock.assigned", `Assigned task ${item.id}`, { owner, task: item });
-    return;
-  }
-  if (type === "lock.acquire") {
-    const resource = body.resource;
-    const owner = body.owner || message.from || "worker";
-    if (!resource) throw new Error("lock.acquire body.resource is required");
-    if (locks[resource])
-      outbox(
-        "lock.denied",
-        `Lock denied ${resource}`,
-        { resource, owner, current: locks[resource] },
-        "warning",
-      );
-    else {
-      locks[resource] = { owner, expiresAt: now() + leaseMs };
-      outbox("lock.granted", `Lock granted ${resource}`, { resource, owner });
-    }
-    writeJson(locksPath, locks);
-    return;
-  }
-  if (type === "lock.renew") {
-    const resource = body.resource;
-    const owner = body.owner || message.from || "worker";
-    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",
-      );
-    } else if (current.owner !== owner) {
-      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 });
-    }
-    writeJson(locksPath, locks);
-    return;
-  }
-  if (type === "lock.release") {
-    const resource = body.resource;
-    if (resource) delete locks[resource];
-    writeJson(locksPath, locks);
-    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;
-    journal(eventType, body);
-    outbox(
-      eventType,
-      `${eventType} ${body.id ?? ""}`.trim(),
-      body,
-      eventType === "lock.fail" ? "error" : "info",
-    );
-    writeJson(locksPath, locks);
-    writeJson(queuePath, queue);
-    return;
-  }
-  journal("lock.unknown", { type, body });
-  outbox("lock.unknown", `Unknown message ${type}`, { type, body }, "warning");
-}
+import { existsSync } from "node:fs";
+import { basename, dirname, join } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
 
-if (mode === "snapshot") {
-  printSnapshot();
-  process.exit(0);
+function packageRoot() {
+  const scriptDir = dirname(fileURLToPath(import.meta.url));
+  const parent = dirname(scriptDir);
+  return basename(parent) === "dist" ? dirname(parent) : parent;
 }
 
-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");
-  }
+function mainModulePath() {
+  const root = packageRoot();
+  const compiled = join(root, "dist", "lib", "locker.js");
+  return existsSync(compiled) ? compiled : join(root, "lib", "locker.ts");
 }
 
-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);
-  }
-}
+const { runLocker } = await import(pathToFileURL(mainModulePath()).href);
 
-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(() => {});
+try {
+  await runLocker(process.argv.slice(2));
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error));
+  process.exit(1);
 }
-
-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);