@syntax-syllogism/sfd 0.0.0-stage → 0.2.0

package/src/server.mjs

@@ -0,0 +1,99 @@
+import net from "node:net";
+import { chmodSync, unlinkSync } from "node:fs";
+
+// Newline-delimited JSON over a Unix socket: one request and one response per connection.
+// Responses are {status: 0, result} | {status: 1, name, message} | {restart: true}.
+
+export class AlreadyRunning extends Error {}
+
+function probe(socket) {
+  return new Promise(resolve => {
+    const s = net.connect(socket, () => { s.destroy(); resolve(true); });
+    s.on("error", () => resolve(false));
+  });
+}
+
+function listenOnce(server, socket) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(socket, () => { server.off("error", reject); resolve(); });
+  });
+}
+
+export async function startServer({ socket, version, handlers, idleMs = 60 * 60_000, isStale = () => false, onExit = () => {} }) {
+  let active = 0;
+  let idleTimer;
+  let draining;
+  let exited = false;
+
+  const maybeExit = () => {
+    if (draining && active === 0 && !exited) {
+      exited = true;
+      onExit(draining);
+    }
+  };
+
+  // Stop accepting connections and free the socket path right away, so a replacement
+  // daemon can bind it, but let in-flight requests (deploys, test runs) finish.
+  const drain = reason => {
+    if (draining) return;
+    draining = reason;
+    clearTimeout(idleTimer);
+    server.close();
+    try { unlinkSync(socket); } catch {}
+    maybeExit();
+  };
+  const armIdle = () => {
+    clearTimeout(idleTimer);
+    idleTimer = setTimeout(() => active === 0 && drain("idle"), idleMs);
+    idleTimer.unref?.();
+  };
+
+  async function respond(req) {
+    if (req.op === "stop") return { status: 0, result: { stopping: true } };
+    if (req.v !== version) return { restart: true };
+    const handler = handlers[req.op];
+    if (!handler) return { status: 1, name: "UnknownOperation", message: `Unknown operation: ${req.op}` };
+    try {
+      return { status: 0, result: await handler(req) };
+    } catch (e) {
+      return { status: 1, name: e.name ?? "Error", message: e.message ?? String(e), errorCode: e.errorCode };
+    }
+  }
+
+  const server = net.createServer(conn => {
+    conn.setEncoding("utf8");
+    let buf = "";
+    conn.on("error", () => {});
+    conn.on("data", async chunk => {
+      buf += chunk;
+      const nl = buf.indexOf("\n");
+      if (nl < 0) return;
+      conn.removeAllListeners("data");
+      active++;
+      clearTimeout(idleTimer);
+      let req;
+      try { req = JSON.parse(buf.slice(0, nl)); } catch { req = {}; }
+      const res = await respond(req);
+      conn.end(JSON.stringify(res) + "\n");
+      active--;
+      if (req.op === "stop") drain("stop");
+      else if (res.restart) drain("version");
+      else if (isStale()) drain("stale");
+      if (draining) maybeExit();
+      else if (active === 0) armIdle();
+    });
+  });
+
+  try {
+    await listenOnce(server, socket);
+  } catch (e) {
+    if (e.code !== "EADDRINUSE") throw e;
+    if (await probe(socket)) throw new AlreadyRunning("sfd is already running");
+    unlinkSync(socket);
+    await listenOnce(server, socket);
+  }
+  chmodSync(socket, 0o600);
+  armIdle();
+  return { server, drain };
+}

package/src/sf-root.mjs

@@ -0,0 +1,26 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { createRequire } from "node:module";
+
+// sfd loads @salesforce/core, SDR, apex-node and source-tracking from the installed sf CLI,
+// so auth files, API versions and metadata registries always match what `sf` itself uses.
+export function findSfRoot(env = process.env) {
+  if (env.SFD_SF_ROOT) return env.SFD_SF_ROOT;
+  const bin = execFileSync("which", ["sf"], { encoding: "utf8" }).trim();
+  for (let dir = dirname(realpathSync(bin)); dirname(dir) !== dir; dir = dirname(dir)) {
+    try {
+      if (JSON.parse(readFileSync(join(dir, "package.json"), "utf8")).name === "@salesforce/cli") return dir;
+    } catch {}
+  }
+  throw new Error(`Could not locate the @salesforce/cli install behind ${bin}; set SFD_SF_ROOT.`);
+}
+
+export function sfInfo(root) {
+  const file = join(root, "package.json");
+  return { root, version: JSON.parse(readFileSync(file, "utf8")).version, mtimeMs: statSync(file).mtimeMs };
+}
+
+export function sfRequire(root) {
+  return createRequire(join(root, "package.json"));
+}

package/src/usage-error.mjs

@@ -0,0 +1 @@
+export class UsageError extends Error {}

package/src/version.mjs

@@ -0,0 +1,10 @@
+import { readdirSync, readFileSync, statSync } from "node:fs";
+
+const pkg = new URL("../package.json", import.meta.url);
+export const VERSION = JSON.parse(readFileSync(pkg, "utf8")).version;
+
+// The client and daemon must run the same code, not just the same package version:
+// fold the newest source mtime in, so an edited or reinstalled checkout replaces a running daemon.
+const src = new URL("./", import.meta.url);
+const newest = Math.max(...readdirSync(src).map(f => statSync(new URL(f, src)).mtimeMs));
+export const PROTOCOL = `${VERSION}+${Math.floor(newest)}`;