frayui 0.1.0

package/dist/codex-app-server-daemon.js

@@ -0,0 +1,354 @@
+import { createRequire as __frayCreateRequire } from "node:module"; const require = __frayCreateRequire(import.meta.url);
+
+// packages/server/src/backend/codex-app-server-daemon.ts
+import { spawn } from "node:child_process";
+import { createServer } from "node:net";
+import { existsSync, readFileSync, unlinkSync as unlinkSync2, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { StringDecoder } from "node:string_decoder";
+
+// packages/server/src/backend/stale-socket-sweep.ts
+import { execFile } from "node:child_process";
+import { readdirSync, unlinkSync } from "node:fs";
+import { connect as connectSocket } from "node:net";
+import { join } from "node:path";
+var defaultListReferenced = (prefix, done) => {
+  execFile("lsof", ["-U", "-F", "n"], { timeout: 3e4, maxBuffer: 16 * 1024 * 1024 }, (error, stdout) => {
+    if (!stdout) return done(null);
+    if (error && !stdout.includes(prefix)) return done(null);
+    const referenced = /* @__PURE__ */ new Set();
+    for (const line of stdout.split("\n")) if (line.startsWith("n/")) referenced.add(line.slice(1));
+    done(referenced);
+  }).unref?.();
+};
+var defaultProbe = (path, verdict) => {
+  const probe = connectSocket(path);
+  probe.unref?.();
+  probe.on("connect", () => {
+    probe.destroy();
+    verdict(false);
+  });
+  probe.on("error", (error) => {
+    probe.destroy();
+    verdict(error.code === "ECONNREFUSED" || error.code === "ENOENT");
+  });
+};
+function sweepStaleSockets(options, deps = {}) {
+  if (process.platform === "win32") return;
+  const keep = new Set(options.keep ?? []);
+  let candidates;
+  try {
+    candidates = (deps.readdir ?? readdirSync)(options.dir).filter((name) => name.startsWith(options.prefix) && name.endsWith(".sock")).map((name) => join(options.dir, name)).filter((path) => !keep.has(path));
+  } catch {
+    return;
+  }
+  if (candidates.length === 0) return;
+  const probe = deps.probe ?? defaultProbe;
+  const unlink = deps.unlink ?? ((path) => {
+    try {
+      unlinkSync(path);
+    } catch {
+    }
+  });
+  (deps.listReferenced ?? defaultListReferenced)(options.prefix, (referenced) => {
+    if (!referenced) return;
+    for (const path of candidates) {
+      if (referenced.has(path)) continue;
+      probe(path, (dead) => {
+        if (dead) unlink(path);
+      });
+    }
+  });
+}
+
+// packages/server/src/backend/codex-app-server-daemon.ts
+var MAX_QUEUED_LINES = 2e4;
+var MAX_QUEUED_BYTES = 64 * 1024 * 1024;
+var MAX_LINE_BYTES = 8 * 1024 * 1024;
+var IDLE_EXIT_MS = 6 * 60 * 60 * 1e3;
+var HANDSHAKE_TIMEOUT_MS = 3e4;
+var REACHABILITY_CHECK_MS = 3e4;
+var REACHABILITY_STRIKES = 2;
+function readConfig() {
+  const raw = process.env.FRAY_CODEX_APP_SERVER_DAEMON;
+  if (!raw) throw new Error("codex app-server daemon started without FRAY_CODEX_APP_SERVER_DAEMON");
+  const config = JSON.parse(raw);
+  if (!config.socketPath || !config.recordPath || !config.codexBin || !config.generation) {
+    throw new Error("codex app-server daemon config is incomplete");
+  }
+  return config;
+}
+function lineReader(onLine) {
+  const decoder = new StringDecoder("utf8");
+  let buffer = "";
+  let overflowed = false;
+  return (chunk) => {
+    buffer += decoder.write(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+    for (; ; ) {
+      const index = buffer.indexOf("\n");
+      if (index < 0) break;
+      const line = buffer.slice(0, index);
+      buffer = buffer.slice(index + 1);
+      if (overflowed) {
+        overflowed = false;
+        continue;
+      }
+      const trimmed = line.trim();
+      if (trimmed) onLine(trimmed);
+    }
+    if (Buffer.byteLength(buffer) > MAX_LINE_BYTES) {
+      buffer = "";
+      overflowed = true;
+    }
+  };
+}
+function main() {
+  const config = readConfig();
+  const child = spawn(config.codexBin, ["app-server", "--stdio"], {
+    cwd: config.cwd,
+    env: config.env,
+    stdio: ["pipe", "pipe", "pipe"]
+  });
+  let client = null;
+  let queuedLines = [];
+  let queuedBytes = 0;
+  let dropped = 0;
+  let idleTimer = null;
+  let published = false;
+  const recordOwner = () => {
+    try {
+      const value = JSON.parse(readFileSync(config.recordPath, "utf8"));
+      return typeof value.daemonPid === "number" ? value.daemonPid : null;
+    } catch {
+      return null;
+    }
+  };
+  const cleanup = () => {
+    try {
+      client?.destroy();
+    } catch {
+    }
+    const owner = recordOwner();
+    if (owner === process.pid) {
+      try {
+        unlinkSync2(config.recordPath);
+      } catch {
+      }
+    }
+    if (published && owner !== null && owner !== process.pid) return;
+    if (published && process.platform !== "win32") {
+      try {
+        unlinkSync2(config.socketPath);
+      } catch {
+      }
+    }
+  };
+  const writeExitBreadcrumb = (reason) => {
+    try {
+      writeFileSync(`${config.recordPath}.exit`, JSON.stringify({
+        projectId: config.projectId,
+        generation: config.generation,
+        daemonPid: process.pid,
+        childPid: child.pid ?? null,
+        reason,
+        at: (/* @__PURE__ */ new Date()).toISOString()
+      }));
+    } catch {
+    }
+  };
+  const die = (code, reason) => {
+    writeExitBreadcrumb(reason);
+    cleanup();
+    process.exit(code);
+  };
+  const armIdleExit = () => {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      ;
+      die(0, "idle-timeout");
+    }, IDLE_EXIT_MS);
+    idleTimer.unref?.();
+  };
+  let unreachableStrikes = 0;
+  const checkReachable = () => {
+    if (client) {
+      unreachableStrikes = 0;
+      return;
+    }
+    if (recordOwner() === process.pid) {
+      unreachableStrikes = 0;
+      return;
+    }
+    if (++unreachableStrikes < REACHABILITY_STRIKES) return;
+    try {
+      child.kill("SIGTERM");
+    } catch {
+    }
+    die(0, "self-collected-record-reassigned");
+  };
+  const toClient = (line) => {
+    if (client) {
+      try {
+        client.write(`${line}
+`);
+        return;
+      } catch {
+      }
+    }
+    if (queuedLines.length >= MAX_QUEUED_LINES || queuedBytes >= MAX_QUEUED_BYTES) {
+      dropped++;
+      return;
+    }
+    queuedLines.push(line);
+    queuedBytes += Buffer.byteLength(line) + 1;
+  };
+  const control = (payload) => JSON.stringify({ fray: 1, ...payload });
+  const HANDSHAKE_ID = -1;
+  let initializeResult;
+  let handshakeDone = false;
+  const pendingFromClient = /* @__PURE__ */ new Map();
+  let nextDaemonId = 1e6;
+  const toServer = (message) => {
+    try {
+      child.stdin.write(`${JSON.stringify(message)}
+`);
+    } catch {
+    }
+  };
+  const readServerLine = (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!handshakeDone && message.id === HANDSHAKE_ID) {
+      if (message.error) die(3, "handshake-rejected");
+      initializeResult = message.result;
+      handshakeDone = true;
+      toServer({ method: "initialized" });
+      startListening();
+      return;
+    }
+    if (message.id !== void 0 && message.method === void 0 && typeof message.id === "number") {
+      const clientId = pendingFromClient.get(message.id);
+      if (clientId !== void 0) {
+        pendingFromClient.delete(message.id);
+        toClient(JSON.stringify({ ...message, id: clientId }));
+        return;
+      }
+    }
+    toClient(line);
+  };
+  const readClientLine = (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (message.method === "initialize") {
+      if (message.id !== void 0) toClient(JSON.stringify({ id: message.id, result: initializeResult }));
+      return;
+    }
+    if (message.method === "initialized") return;
+    if (message.id !== void 0 && message.method !== void 0) {
+      const daemonId = nextDaemonId++;
+      pendingFromClient.set(daemonId, message.id);
+      toServer({ ...message, id: daemonId });
+      return;
+    }
+    toServer(message);
+  };
+  const writeRecord = () => {
+    writeFileSync(config.recordPath, JSON.stringify({
+      projectId: config.projectId,
+      generation: config.generation,
+      daemonPid: process.pid,
+      childPid: child.pid,
+      socketPath: config.socketPath,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }));
+  };
+  const server = createServer((sock) => {
+    if (client) {
+      try {
+        client.destroy();
+      } catch {
+      }
+    }
+    client = sock;
+    if (idleTimer) {
+      clearTimeout(idleTimer);
+      idleTimer = null;
+    }
+    sock.setNoDelay(true);
+    try {
+      sock.write(`${control({ hello: 1, generation: config.generation, childPid: child.pid, droppedWhileDetached: dropped })}
+`);
+      for (const line of queuedLines) sock.write(`${line}
+`);
+    } catch {
+    }
+    queuedLines = [];
+    queuedBytes = 0;
+    dropped = 0;
+    sock.on("data", lineReader(readClientLine));
+    const drop = () => {
+      if (client !== sock) return;
+      client = null;
+      armIdleExit();
+    };
+    sock.on("close", drop);
+    sock.on("error", drop);
+  });
+  const sweepOwnFamily = () => sweepStaleSockets({ dir: dirname(config.socketPath), prefix: "fray-codex-", keep: [config.socketPath] });
+  const startListening = () => {
+    if (process.platform !== "win32" && existsSync(config.socketPath)) {
+      try {
+        unlinkSync2(config.socketPath);
+      } catch {
+      }
+    }
+    server.on("error", () => die(6, "socket-listen-error"));
+    server.listen(config.socketPath, () => {
+      published = true;
+      writeRecord();
+      armIdleExit();
+      const reachability = setInterval(checkReachable, config.reachabilityCheckMs ?? REACHABILITY_CHECK_MS);
+      reachability.unref?.();
+      setTimeout(sweepOwnFamily, 5e3).unref?.();
+    });
+  };
+  child.stdout.on("data", lineReader(readServerLine));
+  child.stderr.resume();
+  child.on("exit", (code, signal) => die(0, signal ? `app-server-killed-${signal}` : `app-server-exited-code-${code ?? "null"}`));
+  child.on("error", () => die(4, "app-server-spawn-error"));
+  toServer({ id: HANDSHAKE_ID, method: "initialize", params: { clientInfo: config.clientInfo, capabilities: config.capabilities } });
+  const handshakeTimer = setTimeout(() => {
+    if (!handshakeDone) {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      ;
+      die(5, "handshake-timeout");
+    }
+  }, HANDSHAKE_TIMEOUT_MS);
+  handshakeTimer.unref?.();
+  for (const signal of ["SIGTERM", "SIGINT", "SIGHUP"]) {
+    process.on(signal, () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      ;
+      die(0, `signal-${signal}`);
+    });
+  }
+}
+main();