@marcoscale98/pi-extensible-workflows 5.19.1-fork.1 → 6.2.1-fork.1

package/dist/trajectory/src/server.js

@@ -1,7 +1,7 @@
 // trajectory/src/server.ts
-import { createHash, randomUUID } from "node:crypto";
+import { createHash, randomUUID as randomUUID3 } from "node:crypto";
 import { createServer } from "node:http";
-import { readFile, rm, writeFile } from "node:fs/promises";
+import { readFile as readFile3, rm as rm3 } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 import { URL } from "node:url";
 
@@ -18,9 +18,12 @@ function trajectoryActionError(action, target) {
   return target.kind === "subagent" && (action === "checkpoint-approve" || action === "checkpoint-reject" || action === "pause" || action === "resume" || action === "share") ? `Trajectory action ${action} is not supported for subagent targets` : target.kind === "run" && action === "steer" ? "Trajectory action steer is not supported for run targets" : void 0;
 }
 
-// src/paths.ts
-import { realpathSync } from "node:fs";
-import { basename, join, resolve } from "node:path";
+// src/io.ts
+import { execFile } from "node:child_process";
+import { randomUUID } from "node:crypto";
+import { renameSync, rmSync, writeFileSync } from "node:fs";
+import { readFile, rename, rm, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
 
 // src/types.ts
 var WORKFLOW_AGENT_STALL_THRESHOLD_MS = 10 * 60 * 1e3;
@@ -1896,12 +1899,78 @@ minimatch.escape = escape;
 minimatch.unescape = unescape;
 
 // src/utils.ts
+function object(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
 var ESCAPE_CHARACTER = String.fromCharCode(27);
 var BELL_CHARACTER = String.fromCharCode(7);
 var ANSI_ESCAPE_SEQUENCE = new RegExp(`${ESCAPE_CHARACTER}(?:\\[[0-?]*[ -/]*[@-~]|\\][^${BELL_CHARACTER}]*(?:${BELL_CHARACTER}|${ESCAPE_CHARACTER}\\\\))`, "g");
 var TERMINAL_CONTROL_CHARACTER = new RegExp(`[${String.fromCharCode(0)}-${String.fromCharCode(31)}${String.fromCharCode(127)}-${String.fromCharCode(159)}]`, "g");
+function positiveInteger(value) {
+  return typeof value === "number" && Number.isInteger(value) && value > 0;
+}
+function isNodeError(error, code) {
+  return object(error) && error.code === code;
+}
+
+// src/io.ts
+var execute = promisify(execFile);
+var RENAME_RETRY_DELAYS_MS = [10, 25, 50, 100, 200, 400, 800];
+var syncSleepBuffer = new Int32Array(new SharedArrayBuffer(4));
+function retryableRenameError(error) {
+  return isNodeError(error, "EPERM") || isNodeError(error, "EBUSY") || isNodeError(error, "EACCES");
+}
+async function renameWithRetry(from, to) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      await rename(from, to);
+      return;
+    } catch (error) {
+      const delayMs = RENAME_RETRY_DELAYS_MS[attempt];
+      if (!retryableRenameError(error) || delayMs === void 0) throw error;
+      await new Promise((resolve2) => setTimeout(resolve2, delayMs));
+    }
+  }
+}
+function renameSyncWithRetry(from, to) {
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      renameSync(from, to);
+      return;
+    } catch (error) {
+      const delayMs = RENAME_RETRY_DELAYS_MS[attempt];
+      if (!retryableRenameError(error) || delayMs === void 0) throw error;
+      Atomics.wait(syncSleepBuffer, 0, 0, delayMs);
+    }
+  }
+}
+function atomicWriteFile(path2, content, sync = false) {
+  const temporary = `${path2}.${String(process.pid)}.${randomUUID()}.tmp`;
+  if (sync) {
+    try {
+      writeFileSync(temporary, content, { encoding: "utf8", mode: 384 });
+      renameSyncWithRetry(temporary, path2);
+    } catch (error) {
+      try {
+        rmSync(temporary, { force: true });
+      } catch {
+      }
+      throw error;
+    }
+    return;
+  }
+  return writeFile(temporary, content, { encoding: "utf8", mode: 384 }).then(() => renameWithRetry(temporary, path2)).catch(async (error) => {
+    try {
+      await rm(temporary, { force: true });
+    } catch {
+    }
+    throw error;
+  });
+}
 
 // src/paths.ts
+import { realpathSync } from "node:fs";
+import { basename, isAbsolute, join, relative, resolve, sep as sep2 } from "node:path";
 function canonicalPath(path2) {
   const absolute = resolve(path2);
   try {
@@ -1914,6 +1983,137 @@ function sameFilesystemPath(left, right) {
   return canonicalPath(left) === canonicalPath(right);
 }
 
+// trajectory/src/startup-mutex.ts
+import { randomUUID as randomUUID2 } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { mkdir, readdir, readFile as readFile2, rm as rm2 } from "node:fs/promises";
+import { join as join2 } from "node:path";
+var bootId;
+function processStart(pid) {
+  if (process.platform !== "linux") return void 0;
+  try {
+    bootId ??= readFileSync("/proc/sys/kernel/random/boot_id", "utf8").trim();
+    const stat = readFileSync(`/proc/${String(pid)}/stat`, "utf8");
+    const startTicks = stat.slice(stat.lastIndexOf(")") + 2).split(" ")[19];
+    return startTicks === void 0 || !/^\d+$/.test(startTicks) ? void 0 : `${bootId}:${startTicks}`;
+  } catch {
+    return void 0;
+  }
+}
+function processLive(identity) {
+  try {
+    process.kill(identity.pid, 0);
+  } catch (error) {
+    if (isNodeError(error, "ESRCH")) return false;
+  }
+  if (identity.start === void 0) return true;
+  const current = processStart(identity.pid);
+  return current === void 0 || current === identity.start;
+}
+function processConfirmed(identity) {
+  return identity.start !== void 0 && processStart(identity.pid) === identity.start;
+}
+function holderDirectory(lockPath) {
+  return `${lockPath}.startup`;
+}
+function holderPath(lockPath, token) {
+  return join2(holderDirectory(lockPath), `${token}.json`);
+}
+function identityOf(pid) {
+  const start = processStart(pid);
+  return start === void 0 ? { pid } : { pid, start };
+}
+function processIdentity(value) {
+  if (!object(value) || !positiveInteger(value.pid)) return void 0;
+  return typeof value.start === "string" ? { pid: value.pid, start: value.start } : { pid: value.pid };
+}
+function decodeHolder(text) {
+  try {
+    const parsed = JSON.parse(text);
+    const holder = processIdentity(parsed);
+    if (holder === void 0 || !object(parsed) || typeof parsed.token !== "string") return void 0;
+    const server = processIdentity(parsed.server);
+    return { ...holder, token: parsed.token, ...server === void 0 ? {} : { server } };
+  } catch {
+    return void 0;
+  }
+}
+function readStartupHolder(lockPath, token) {
+  try {
+    return decodeHolder(readFileSync(holderPath(lockPath, token), "utf8"));
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return void 0;
+    throw error;
+  }
+}
+async function serverPending(lockPath, server) {
+  if (!processLive(server)) return false;
+  let text;
+  try {
+    text = await readFile2(lockPath, "utf8");
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return true;
+    throw error;
+  }
+  try {
+    const lock = JSON.parse(text);
+    return !(object(lock) && lock.pid === server.pid);
+  } catch {
+    return true;
+  }
+}
+async function holderLive(lockPath, path2, read) {
+  if (processLive(read)) return true;
+  let holder;
+  try {
+    holder = decodeHolder(await readFile2(path2, "utf8"));
+  } catch (error) {
+    if (isNodeError(error, "ENOENT")) return false;
+    throw error;
+  }
+  if (holder?.server === void 0 || !await serverPending(lockPath, holder.server)) return false;
+  if (!processConfirmed(holder.server)) return true;
+  try {
+    process.kill(holder.server.pid, "SIGKILL");
+  } catch (error) {
+    if (!isNodeError(error, "ESRCH")) throw error;
+  }
+  return true;
+}
+async function tryAcquireStartupMutex(lockPath) {
+  const directory = holderDirectory(lockPath);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const token = randomUUID2();
+  const own = `${token}.json`;
+  await atomicWriteFile(join2(directory, own), `${JSON.stringify({ ...identityOf(process.pid), token })}
+`);
+  let contended = false;
+  try {
+    for (const name of await readdir(directory)) {
+      if (name === own || !name.endsWith(".json")) continue;
+      const path2 = join2(directory, name);
+      let holder;
+      try {
+        holder = decodeHolder(await readFile2(path2, "utf8"));
+      } catch (error) {
+        if (isNodeError(error, "ENOENT")) continue;
+        throw error;
+      }
+      if (holder !== void 0 && await holderLive(lockPath, path2, holder)) contended = true;
+      else await rm2(path2, { force: true });
+    }
+  } catch (error) {
+    await rm2(join2(directory, own), { force: true });
+    throw error;
+  }
+  if (!contended) return token;
+  await rm2(join2(directory, own), { force: true });
+  return void 0;
+}
+async function releaseStartupMutex(lockPath, token) {
+  await rm2(holderPath(lockPath, token), { force: true });
+}
+
 // src/tool-timing.ts
 var TOOL_TIMING_ENTRY_TYPE = "pi-workflows:tool-timing";
 
@@ -2233,7 +2433,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
     return requests;
   };
   const hasPendingRequest = (requests, requestId) => [...requests.values()].some((request) => request.requestId === requestId);
-  const publisherRequestIdFor = (requestId) => [...pending.values()].some((requests) => requests.has(requestId)) ? randomUUID() : requestId;
+  const publisherRequestIdFor = (requestId) => [...pending.values()].some((requests) => requests.has(requestId)) ? randomUUID3() : requestId;
   const errorResponse = (_publisherRequestId, request, status, error) => request.kind === "action" ? { type: "action-result", requestId: request.requestId, ok: false, error } : { type: "transcript", requestId: request.requestId, publisherId: request.publisherId, ...request.target.runId === void 0 ? {} : { runId: request.target.runId }, ...request.target.agentId === void 0 ? {} : { agentId: request.target.agentId }, ...request.target.subagentId === void 0 ? {} : { subagentId: request.target.subagentId }, ok: false, status, revision: request.target.revision ?? 0, error };
   const clearPending = (client, error) => {
     const own = pending.get(client);
@@ -2262,21 +2462,45 @@ function createTrajectoryServer(port, lockPath, options = {}) {
     if (!requests.size) pending.delete(browser);
     emit(browser, errorResponse(requestId, request, "failed", error));
   };
+  const busy = () => closed || [...publishers.values()].some(({ value }) => value.connected === true);
   const scheduleIdleExit = () => {
-    if (closed || [...publishers.values()].some(({ value }) => value.connected === true) || idleTimer !== void 0) return;
+    if (busy() || idleTimer !== void 0) return;
     idleTimer = setTimeout(() => {
-      server.closeAllConnections();
-      for (const client of clients) client.socket.destroy();
-      server.close(() => {
-        void rm(lockPath, { force: true }).then(() => {
-          process.exit(0);
-        }).catch(() => {
-          process.exit(1);
+      idleTimer = void 0;
+      void tryAcquireStartupMutex(lockPath).then(async (token) => {
+        if (token === void 0) {
+          scheduleIdleExit();
+          return;
+        }
+        if (busy() || idleTimer !== void 0) {
+          await releaseStartupMutex(lockPath, token);
+          return;
+        }
+        server.closeAllConnections();
+        for (const client of clients) client.socket.destroy();
+        server.close(() => {
+          void removeOwnLock().then(() => releaseStartupMutex(lockPath, token)).then(() => {
+            process.exit(0);
+          }).catch(() => {
+            process.exit(1);
+          });
         });
+      }).catch(() => {
+        process.exit(1);
       });
     }, TRAJECTORY_IDLE_EXIT_MS);
     idleTimer.unref();
   };
+  const removeOwnLock = async () => {
+    let current;
+    try {
+      current = JSON.parse(await readFile3(lockPath, "utf8"));
+    } catch (error) {
+      if (isNodeError(error, "ENOENT")) return;
+      throw error;
+    }
+    if (object(current) && current.pid === process.pid && current.startedAt === startedAt) await rm3(lockPath, { force: true });
+  };
   const cancelIdleExit = () => {
     if (idleTimer !== void 0) {
       clearTimeout(idleTimer);
@@ -2423,7 +2647,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       const runRequest = validId(message.runId) && validId(message.agentId) && message.subagentId === void 0;
       const subagentRequest = validId(message.subagentId) && message.runId === void 0 && message.agentId === void 0;
       if (!runRequest && !subagentRequest) return;
-      const requestId2 = validId(message.requestId) ? message.requestId : randomUUID();
+      const requestId2 = validId(message.requestId) ? message.requestId : randomUUID3();
       const revision = message.revision === void 0 ? void 0 : typeof message.revision === "number" && Number.isSafeInteger(message.revision) && message.revision >= 0 ? message.revision : void 0;
       const target2 = publishers.get(message.publisherId);
       if (!target2 || !target2.value.connected) {
@@ -2471,7 +2695,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       return;
     }
     if (client.kind !== "browser" || message.type !== "ui:action" || typeof message.publisherId !== "string") return;
-    const requestId = typeof message.requestId === "string" && message.requestId.length >= 1 && message.requestId.length <= 200 ? message.requestId : randomUUID();
+    const requestId = typeof message.requestId === "string" && message.requestId.length >= 1 && message.requestId.length <= 200 ? message.requestId : randomUUID3();
     if (!isTrajectoryAction(message.action)) {
       emit(client, { type: "action-result", requestId, ok: false, error: "Unsupported Trajectory action" });
       return;
@@ -2525,7 +2749,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       return;
     }
     if (request.method === "GET" && (path2 === "/" || path2 === "/index.html")) {
-      void readFile(new URL("./assets/index.html", import.meta.url)).then((html) => {
+      void readFile3(new URL("./assets/index.html", import.meta.url)).then((html) => {
         response.writeHead(200, { "content-type": "text/html; charset=utf-8", "content-length": html.byteLength, "cache-control": "no-store" });
         response.end(html);
       }).catch(() => {
@@ -2534,7 +2758,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       return;
     }
     if (request.method === "GET" && path2 === "/marked.min.js") {
-      void readFile(new URL("./assets/marked.min.js", import.meta.url)).then((script) => {
+      void readFile3(new URL("./assets/marked.min.js", import.meta.url)).then((script) => {
         response.writeHead(200, { "content-type": "application/javascript; charset=utf-8", "content-length": script.byteLength, "cache-control": "no-store" });
         response.end(script);
       }).catch(() => {
@@ -2543,7 +2767,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       return;
     }
     if (request.method === "GET" && path2 === "/morphdom.min.js") {
-      void readFile(new URL("./assets/morphdom.min.js", import.meta.url)).then((script) => {
+      void readFile3(new URL("./assets/morphdom.min.js", import.meta.url)).then((script) => {
         response.writeHead(200, { "content-type": "application/javascript; charset=utf-8", "content-length": script.byteLength, "cache-control": "no-store" });
         response.end(script);
       }).catch(() => {
@@ -2552,7 +2776,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       return;
     }
     if (request.method === "GET" && path2 === "/prism.min.js") {
-      void readFile(new URL("./assets/prism.min.js", import.meta.url)).then((script) => {
+      void readFile3(new URL("./assets/prism.min.js", import.meta.url)).then((script) => {
         response.writeHead(200, { "content-type": "application/javascript; charset=utf-8", "content-length": script.byteLength, "cache-control": "no-store" });
         response.end(script);
       }).catch(() => {
@@ -2561,7 +2785,7 @@ function createTrajectoryServer(port, lockPath, options = {}) {
       return;
     }
     if (request.method === "GET" && (path2 === "/favicon.png" || path2 === "/favicon.ico")) {
-      void readFile(new URL("./assets/favicon.png", import.meta.url)).then((icon) => {
+      void readFile3(new URL("./assets/favicon.png", import.meta.url)).then((icon) => {
         response.writeHead(200, { "content-type": "image/png", "content-length": icon.byteLength, "cache-control": "no-store" });
         response.end(icon);
       }).catch(() => {
@@ -2621,10 +2845,14 @@ Sec-WebSocket-Accept: ${accept}\r
   });
   server.once("listening", () => {
     startedAt = Date.now();
-    void writeFile(lockPath, `${JSON.stringify({ pid: process.pid, port, fingerprint: serverFingerprint, startedAt })}
-`, { mode: 384 }).catch(() => {
-      process.exitCode = 1;
-    });
+    try {
+      atomicWriteFile(lockPath, `${JSON.stringify({ pid: process.pid, port, fingerprint: serverFingerprint, startedAt, start: processStart(process.pid) })}
+`, true);
+    } catch (error) {
+      server.close();
+      server.emit("error", error);
+      return;
+    }
     scheduleIdleExit();
   });
   server.on("close", () => {
@@ -2636,13 +2864,24 @@ Sec-WebSocket-Accept: ${accept}\r
   });
   return server;
 }
+async function awaitStartupRecord(lockPath, token) {
+  for (let attempt = 0; attempt < 60; attempt += 1) {
+    const holder = readStartupHolder(lockPath, token);
+    if (holder === void 0) break;
+    if (holder.server?.pid === process.pid) return;
+    await new Promise((resolve2) => setTimeout(resolve2, 50));
+  }
+  throw new Error("Trajectory startup was abandoned before the server listened");
+}
 async function main() {
   const args = /* @__PURE__ */ new Map();
   for (let index = 2; index + 1 < process.argv.length; index += 2) args.set(process.argv[index] ?? "", process.argv[index + 1] ?? "");
   const port = Number(args.get("--port"));
   const lockPath = args.get("--lock");
   const fingerprint = args.get("--fingerprint");
+  const startupToken = args.get("--startup");
   if (!Number.isSafeInteger(port) || port < 1 || port > 65535 || !lockPath || !fingerprint) throw new Error("Invalid Trajectory server arguments");
+  if (startupToken !== void 0) await awaitStartupRecord(lockPath, startupToken);
   const server = createTrajectoryServer(port, lockPath, { fingerprint });
   await new Promise((resolve2, reject) => {
     server.once("error", reject);