pwragent 0.0.0 → 1.3.7

package/src/codex.js

@@ -0,0 +1,112 @@
+import { spawn } from "node:child_process";
+import { readMessages, MAX_RESPONSE_BYTES } from "./wire.js";
+
+// This adapter deliberately supports only the stable App Server job surface.
+// It never reads Codex's storage or imports Electron/desktop modules.
+export class Codex {
+  constructor({ command, home, workspace, onNotification, onRequest, onFailure, timeout = 30000 }) {
+    this.pending = new Map();
+    this.sequence = 0;
+    this.timeout = timeout;
+    this.onFailure = onFailure;
+    const env = { ...process.env, CODEX_HOME: home };
+    for (const key of Object.keys(env)) {
+      if (key.toUpperCase() === "ELECTRON_RENDERER_URL") delete env[key];
+    }
+    this.child = spawn(command, ["app-server", "--listen", "stdio://"], {
+      cwd: workspace,
+      env,
+      stdio: ["pipe", "pipe", "pipe"],
+      // A dedicated group lets shutdown reap ordinary descendants on POSIX.
+      detached: true,
+    });
+    this.closed = new Promise((resolve) => this.child.once("close", resolve));
+    this.child.on("error", () => this.fail(new Error("Could not start Codex App Server")));
+    this.child.on("exit", () => this.fail(new Error("Codex App Server exited")));
+    this.child.stdin.on("error", () => this.fail(new Error("Codex App Server input closed")));
+    // Drain diagnostics without copying potentially sensitive provider text to
+    // the journal. Request errors are returned to the private local client.
+    this.child.stderr.resume();
+    readMessages(this.child.stdout, MAX_RESPONSE_BYTES, (message) => {
+      if (typeof message.method === "string") {
+        if (message.id !== undefined) onRequest(message);
+        else onNotification(message);
+        return;
+      }
+      const request = this.pending.get(message.id);
+      if (!request) return;
+      if (!("error" in message) && !("result" in message)) {
+        this.fail(new Error("Invalid Codex response"));
+        return;
+      }
+      this.pending.delete(message.id);
+      clearTimeout(request.timer);
+      if (message.error) request.reject(new Error(message.error.message || "Codex request failed"));
+      else if ("result" in message) request.resolve(message.result);
+    }, (error) => this.fail(error));
+  }
+
+  fail(error) {
+    if (this.failure) return;
+    this.failure = error;
+    for (const request of this.pending.values()) {
+      clearTimeout(request.timer);
+      request.reject(error);
+    }
+    this.pending.clear();
+    if (!this.stopping) this.onFailure(error);
+  }
+
+  send(message) {
+    if (this.failure || this.stopping) throw this.failure || new Error("Codex is stopping");
+    this.child.stdin.write(JSON.stringify(message) + "\n");
+  }
+
+  request(method, params) {
+    if (this.failure || this.stopping) return Promise.reject(this.failure || new Error("Codex is stopping"));
+    if (this.pending.size >= 32) return Promise.reject(new Error("Too many pending Codex requests"));
+    const id = ++this.sequence;
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        // A timeout may mean a mutation executed but its reply was lost.
+        // Stop the runtime; never retry an uncertain turn/start.
+        this.fail(new Error(`Codex request timed out: ${method}`));
+      }, this.timeout);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.send({ id, method, params });
+      } catch (error) {
+        this.fail(error);
+      }
+    });
+  }
+
+  async initialize() {
+    await this.request("initialize", {
+      clientInfo: { name: "pwragent-headless", title: "PwrAgent Headless", version: "0.0.0" },
+      capabilities: { experimentalApi: true },
+    });
+    this.send({ method: "initialized", params: {} });
+  }
+
+  async stop() {
+    this.stopping = true;
+    this.fail(new Error("Codex stopped"));
+    const signal = (name) => {
+      if (!this.child.pid) return;
+      try {
+        process.kill(-this.child.pid, name);
+      } catch (error) {
+        if (error.code !== "ESRCH") throw error;
+      }
+    };
+    signal("SIGTERM");
+    let timer;
+    await Promise.race([this.closed, new Promise((resolve) => { timer = setTimeout(resolve, 2000); })]);
+    clearTimeout(timer);
+    // Also reap descendants that outlived the group leader. systemd's cgroup
+    // owns processes that deliberately leave this group.
+    signal("SIGKILL");
+    await this.closed;
+  }
+}

package/src/daemon.js

@@ -0,0 +1,125 @@
+import { closeSync, openSync, realpathSync, statSync, unlinkSync, writeFileSync } from "node:fs";
+import net from "node:net";
+import path from "node:path";
+import { JobStore, privateDirectory } from "./store.js";
+import { Runtime } from "./runtime.js";
+import { HeadlessFederation } from "./federation.js";
+import { MAX_REQUEST_BYTES, MAX_RESPONSE_BYTES, readMessages } from "./wire.js";
+
+export async function serve({ directory, workspace, home, command, profile }) {
+  if (!["linux", "darwin"].includes(process.platform)) throw new Error("Headless currently supports Linux and macOS only");
+  for (const value of [workspace, home, command]) {
+    if (!value || !path.isAbsolute(value)) throw new Error("serve requires absolute --workspace, --codex-home and --codex-bin paths");
+  }
+  workspace = realpathSync(workspace);
+  home = realpathSync(home);
+  if (!statSync(workspace).isDirectory() || !statSync(home).isDirectory()) throw new Error("Workspace and Codex home must be directories");
+  privateDirectory(directory);
+  directory = realpathSync(directory);
+  const roots = [directory, workspace, home];
+  for (let i = 0; i < roots.length; i++) {
+    for (let j = i + 1; j < roots.length; j++) {
+      if (roots[i] === roots[j] || roots[i].startsWith(roots[j] + path.sep) || roots[j].startsWith(roots[i] + path.sep)) {
+        throw new Error("Workspace, Codex home and headless state must be separate, non-overlapping directories");
+      }
+    }
+  }
+  const socketPath = path.join(directory, "rpc.sock");
+  if (Buffer.byteLength(socketPath) > 100) throw new Error("Headless socket path exceeds 100 bytes; choose a shorter PWRAGENT_HOME");
+  const lockPath = path.join(directory, "owner.lock");
+  let lock;
+  try { lock = openSync(lockPath, "wx", 0o600); } catch (error) {
+    if (error.code === "EEXIST") throw new Error(`Headless owner lock already exists: ${lockPath}. See README crash recovery; never remove a live owner's lock.`, { cause: error });
+    throw error;
+  }
+  let runtime;
+  let federation;
+  let server;
+  let listening = false;
+  let shutdown;
+  let exitCode = 0;
+  let resolveDone;
+  const done = new Promise((resolve) => { resolveDone = resolve; });
+  const sockets = new Set();
+  const stop = (error) => {
+    if (error) exitCode = 1;
+    if (shutdown) return shutdown;
+    shutdown = (async () => {
+      if (listening) server.close();
+      for (const socket of sockets) socket.destroy();
+      try {
+        try { await federation?.stop(); } finally { await runtime?.stop(); }
+      } finally {
+        closeSync(lock);
+        unlinkSync(lockPath);
+        process.off("SIGTERM", signalStop);
+        process.off("SIGINT", signalStop);
+        resolveDone(exitCode);
+      }
+    })();
+    // Persistence/cleanup failure must fail the process, not become an
+    // unhandled rejection that leaves a healthy-looking daemon running.
+    shutdown.catch((failure) => { console.error(failure.message); resolveDone(1); });
+    return shutdown;
+  };
+  const signalStop = () => { void stop(); };
+  try {
+    writeFileSync(lock, JSON.stringify({ pid: process.pid }) + "\n");
+    const store = new JobStore(directory, { version: 1, workspace, codexHome: home });
+    runtime = new Runtime({ store, workspace, home, command,
+      onFailure: (error) => { console.error(`Headless runtime stopped: ${error.message}`); void stop(error); } });
+    writeFileSync(lockPath, JSON.stringify({ pid: process.pid, codexPid: runtime.codex.child.pid }) + "\n");
+    process.on("SIGTERM", signalStop);
+    process.on("SIGINT", signalStop);
+    await runtime.codex.initialize();
+    federation = new HeadlessFederation({ directory, runtime, profile, onFailure: (error) => { void stop(error); } });
+    await federation.start();
+    if (shutdown) return done;
+    server = net.createServer((socket) => {
+      if (sockets.size >= 64) { socket.destroy(); return; }
+      sockets.add(socket);
+      socket.on("close", () => sockets.delete(socket));
+      socket.on("error", () => socket.destroy());
+      socket.setTimeout(60000, () => socket.destroy());
+      let accepted = false;
+      readMessages(socket, MAX_REQUEST_BYTES, (message) => {
+        if (accepted) { socket.destroy(); return; }
+        accepted = true;
+        const respond = (response) => {
+          if (socket.destroyed) return;
+          const data = JSON.stringify(response) + "\n";
+          if (Buffer.byteLength(data) > MAX_RESPONSE_BYTES) {
+            socket.end(JSON.stringify({ error: "Response exceeds 32 MiB; inspect the thread using a compatible Codex client" }) + "\n");
+          } else socket.end(data);
+        };
+        if (message.version !== 1 || typeof message.method !== "string") {
+          respond({ error: "Unsupported headless protocol" });
+          return;
+        }
+        Promise.resolve().then(() => {
+          const params = message.params || {};
+          switch (message.method) {
+            case "federation-status": return federation.status();
+            case "federation-join": return federation.join(params);
+            case "federation-invite": return federation.invite(params);
+            case "federation-leave": return federation.leave();
+            case "federation-revoke": return federation.revoke(params.peer);
+            default: return runtime.handle(message.method, params);
+          }
+        })
+          .then((result) => respond({ result }), (error) => respond({ error: error.message }));
+      }, () => socket.destroy());
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(socketPath, () => { listening = true; resolve(); });
+    });
+    if (shutdown) { server.close(); return await done; }
+    server.on("error", (error) => { void stop(error); });
+    console.log(JSON.stringify({ ready: true, socket: socketPath, pid: process.pid }));
+    return await done;
+  } catch (error) {
+    await stop(error);
+    throw error;
+  }
+}