@outfitter/daemon 0.1.0-rc.1

package/dist/index.js

@@ -0,0 +1,618 @@
+// src/types.ts
+import { TaggedError } from "@outfitter/contracts";
+var DaemonErrorBase = TaggedError("DaemonError")();
+
+class DaemonError extends DaemonErrorBase {
+}
+// src/errors.ts
+import { TaggedError as TaggedError2 } from "@outfitter/contracts";
+var StaleSocketErrorBase = TaggedError2("StaleSocketError")();
+var ConnectionRefusedErrorBase = TaggedError2("ConnectionRefusedError")();
+var ConnectionTimeoutErrorBase = TaggedError2("ConnectionTimeoutError")();
+var ProtocolErrorBase = TaggedError2("ProtocolError")();
+var LockErrorBase = TaggedError2("LockError")();
+
+class StaleSocketError extends StaleSocketErrorBase {
+}
+
+class ConnectionRefusedError extends ConnectionRefusedErrorBase {
+}
+
+class ConnectionTimeoutError extends ConnectionTimeoutErrorBase {
+}
+
+class ProtocolError extends ProtocolErrorBase {
+}
+
+class LockError extends LockErrorBase {
+}
+// src/platform.ts
+import { platform as osPlatform, tmpdir, userInfo } from "node:os";
+import { join } from "node:path";
+function isUnixPlatform() {
+  const plat = osPlatform();
+  return plat === "darwin" || plat === "linux";
+}
+function getRuntimeDir() {
+  const xdgRuntime = process.env["XDG_RUNTIME_DIR"];
+  if (xdgRuntime) {
+    return xdgRuntime;
+  }
+  const plat = osPlatform();
+  if (plat === "darwin") {
+    return process.env["TMPDIR"] ?? tmpdir();
+  }
+  if (plat === "linux") {
+    return `/run/user/${userInfo().uid}`;
+  }
+  return process.env["TEMP"] ?? tmpdir();
+}
+function getSocketPath(toolName) {
+  if (!isUnixPlatform()) {
+    return `\\\\.\\pipe\\${toolName}-daemon`;
+  }
+  return join(getRuntimeDir(), toolName, "daemon.sock");
+}
+function getLockPath(toolName) {
+  if (!isUnixPlatform()) {
+    return join(tmpdir(), `${toolName}-daemon.lock`);
+  }
+  return join(getRuntimeDir(), toolName, "daemon.lock");
+}
+function getPidPath(toolName) {
+  if (!isUnixPlatform()) {
+    return join(tmpdir(), `${toolName}-daemon.pid`);
+  }
+  return join(getRuntimeDir(), toolName, "daemon.pid");
+}
+function getDaemonDir(toolName) {
+  if (!isUnixPlatform()) {
+    return tmpdir();
+  }
+  return join(getRuntimeDir(), toolName);
+}
+// src/locking.ts
+import { unlink } from "node:fs/promises";
+function isProcessAlive(pid) {
+  if (pid <= 0) {
+    return false;
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "EPERM") {
+      return true;
+    }
+    return false;
+  }
+}
+async function isDaemonAlive(lockPath) {
+  const file = Bun.file(lockPath);
+  if (!await file.exists()) {
+    return false;
+  }
+  try {
+    const content = await file.text();
+    const pid = Number.parseInt(content.trim(), 10);
+    if (Number.isNaN(pid)) {
+      return false;
+    }
+    return isProcessAlive(pid);
+  } catch {
+    return false;
+  }
+}
+async function acquireDaemonLock(lockPath) {
+  const file = Bun.file(lockPath);
+  if (await file.exists()) {
+    try {
+      const content = await file.text();
+      const existingPid = Number.parseInt(content.trim(), 10);
+      if (!Number.isNaN(existingPid) && isProcessAlive(existingPid)) {
+        return {
+          isOk: () => false,
+          isErr: () => true,
+          error: new LockError({
+            message: `Daemon already running with PID ${existingPid}`,
+            lockPath,
+            pid: existingPid
+          })
+        };
+      }
+    } catch {}
+  }
+  const pid = process.pid;
+  try {
+    await Bun.write(lockPath, `${pid}
+`);
+    return {
+      isOk: () => true,
+      isErr: () => false,
+      value: { lockPath, pid }
+    };
+  } catch (error) {
+    return {
+      isOk: () => false,
+      isErr: () => true,
+      error: new LockError({
+        message: `Failed to write lock file: ${error instanceof Error ? error.message : String(error)}`,
+        lockPath,
+        pid
+      })
+    };
+  }
+}
+async function releaseDaemonLock(handle) {
+  const { lockPath, pid } = handle;
+  const file = Bun.file(lockPath);
+  if (!await file.exists()) {
+    return;
+  }
+  try {
+    const content = await file.text();
+    const filePid = Number.parseInt(content.trim(), 10);
+    if (filePid === pid) {
+      await unlink(lockPath);
+    }
+  } catch {}
+}
+async function readLockPid(lockPath) {
+  const file = Bun.file(lockPath);
+  if (!await file.exists()) {
+    return;
+  }
+  try {
+    const content = await file.text();
+    const pid = Number.parseInt(content.trim(), 10);
+    return Number.isNaN(pid) ? undefined : pid;
+  } catch {
+    return;
+  }
+}
+// src/lifecycle.ts
+import { mkdir, unlink as unlink2, writeFile } from "node:fs/promises";
+import { dirname } from "node:path";
+import { Result } from "@outfitter/contracts";
+function pidFileExists(path) {
+  return Bun.file(path).exists();
+}
+async function writePidFile(path, pid) {
+  try {
+    const dir = dirname(path);
+    await mkdir(dir, { recursive: true });
+    await writeFile(path, String(pid), { flag: "wx" });
+    return Result.ok(undefined);
+  } catch (error) {
+    return Result.err(new DaemonError({
+      code: "PID_ERROR",
+      message: `Failed to write PID file: ${error instanceof Error ? error.message : "Unknown error"}`
+    }));
+  }
+}
+async function removePidFile(path) {
+  try {
+    await unlink2(path);
+    return Result.ok(undefined);
+  } catch (error) {
+    if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+      return Result.ok(undefined);
+    }
+    return Result.err(new DaemonError({
+      code: "PID_ERROR",
+      message: `Failed to remove PID file: ${error instanceof Error ? error.message : "Unknown error"}`
+    }));
+  }
+}
+async function runShutdownHandlers(handlers, timeout, logger) {
+  const errors = [];
+  const runHandlers = async () => {
+    for (const handler of handlers) {
+      try {
+        await handler();
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error(String(error));
+        errors.push(err);
+        logger?.warn("Shutdown handler failed", { error: err.message });
+      }
+    }
+  };
+  const timeoutPromise = new Promise((resolve) => {
+    setTimeout(() => resolve("timeout"), timeout);
+  });
+  const result = await Promise.race([
+    runHandlers().then(() => "completed"),
+    timeoutPromise
+  ]);
+  return {
+    completed: result === "completed",
+    errors
+  };
+}
+function createDaemon(options) {
+  const internalState = {
+    state: "stopped",
+    options: {
+      name: options.name,
+      pidFile: options.pidFile,
+      logger: options.logger,
+      shutdownTimeout: options.shutdownTimeout ?? 5000
+    },
+    shutdownHandlers: [],
+    signalHandlers: {},
+    isShuttingDown: false
+  };
+  async function doStop() {
+    const { logger } = internalState.options;
+    if (internalState.isShuttingDown) {
+      return Result.ok(undefined);
+    }
+    if (internalState.state === "stopped") {
+      return Result.err(new DaemonError({
+        code: "NOT_RUNNING",
+        message: `Daemon "${internalState.options.name}" is not running`
+      }));
+    }
+    internalState.isShuttingDown = true;
+    internalState.state = "stopping";
+    logger?.info("Daemon stopping", { name: internalState.options.name });
+    const { completed } = await runShutdownHandlers(internalState.shutdownHandlers, internalState.options.shutdownTimeout, logger);
+    if (!completed) {
+      logger?.warn("Shutdown handlers timed out", {
+        name: internalState.options.name,
+        timeout: internalState.options.shutdownTimeout
+      });
+    }
+    if (internalState.signalHandlers.sigterm) {
+      process.off("SIGTERM", internalState.signalHandlers.sigterm);
+    }
+    if (internalState.signalHandlers.sigint) {
+      process.off("SIGINT", internalState.signalHandlers.sigint);
+    }
+    const removeResult = await removePidFile(internalState.options.pidFile);
+    if (removeResult.isErr()) {
+      logger?.error("Failed to remove PID file", {
+        error: removeResult.error.message
+      });
+    }
+    internalState.state = "stopped";
+    internalState.isShuttingDown = false;
+    logger?.info("Daemon stopped", { name: internalState.options.name });
+    if (!completed) {
+      return Result.err(new DaemonError({
+        code: "SHUTDOWN_TIMEOUT",
+        message: `Shutdown handlers exceeded timeout of ${internalState.options.shutdownTimeout}ms`
+      }));
+    }
+    return Result.ok(undefined);
+  }
+  const daemon = {
+    get state() {
+      return internalState.state;
+    },
+    async start() {
+      const { logger } = internalState.options;
+      if (internalState.state !== "stopped") {
+        return Result.err(new DaemonError({
+          code: "ALREADY_RUNNING",
+          message: `Daemon "${internalState.options.name}" is already running`
+        }));
+      }
+      internalState.state = "starting";
+      logger?.info("Daemon starting", { name: internalState.options.name });
+      if (await pidFileExists(internalState.options.pidFile)) {
+        internalState.state = "stopped";
+        return Result.err(new DaemonError({
+          code: "ALREADY_RUNNING",
+          message: `PID file already exists: ${internalState.options.pidFile}`
+        }));
+      }
+      const writeResult = await writePidFile(internalState.options.pidFile, process.pid);
+      if (writeResult.isErr()) {
+        internalState.state = "stopped";
+        return writeResult;
+      }
+      const sigTermHandler = () => {
+        logger?.info("Received SIGTERM signal");
+        doStop();
+      };
+      const sigIntHandler = () => {
+        logger?.info("Received SIGINT signal");
+        doStop();
+      };
+      internalState.signalHandlers.sigterm = sigTermHandler;
+      internalState.signalHandlers.sigint = sigIntHandler;
+      process.on("SIGTERM", sigTermHandler);
+      process.on("SIGINT", sigIntHandler);
+      internalState.state = "running";
+      logger?.info("Daemon started", {
+        name: internalState.options.name,
+        pid: process.pid
+      });
+      return Result.ok(undefined);
+    },
+    stop() {
+      return doStop();
+    },
+    isRunning() {
+      return internalState.state === "running";
+    },
+    onShutdown(handler) {
+      internalState.shutdownHandlers.push(handler);
+    }
+  };
+  return daemon;
+}
+// src/ipc.ts
+import { unlink as unlink3 } from "node:fs/promises";
+function createIpcServer(socketPath) {
+  let messageHandler = null;
+  let server = null;
+  let isListening = false;
+  const socketBuffers = new WeakMap;
+  function processSocketBuffer(socket) {
+    const buffer = socketBuffers.get(socket) ?? "";
+    const lines = buffer.split(`
+`);
+    socketBuffers.set(socket, lines.pop() ?? "");
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const message = JSON.parse(line);
+        if (message.type === "request" && messageHandler) {
+          (async () => {
+            try {
+              const result = await messageHandler(message.payload);
+              const response = {
+                id: message.id,
+                type: "response",
+                payload: result
+              };
+              socket.write(`${JSON.stringify(response)}
+`);
+            } catch (error) {
+              const errorResponse = {
+                id: message.id,
+                type: "error",
+                payload: {
+                  message: error instanceof Error ? error.message : "Unknown error"
+                }
+              };
+              socket.write(`${JSON.stringify(errorResponse)}
+`);
+            }
+          })();
+        }
+      } catch {}
+    }
+  }
+  return {
+    async listen() {
+      if (isListening)
+        return;
+      try {
+        await unlink3(socketPath);
+      } catch {}
+      server = Bun.listen({
+        unix: socketPath,
+        socket: {
+          data(socket, data) {
+            const text = Buffer.isBuffer(data) ? data.toString("utf-8") : String(data);
+            const currentBuffer = socketBuffers.get(socket) ?? "";
+            socketBuffers.set(socket, currentBuffer + text);
+            processSocketBuffer(socket);
+          },
+          open(socket) {
+            socketBuffers.set(socket, "");
+          },
+          close(socket) {
+            socketBuffers.delete(socket);
+          },
+          error() {}
+        }
+      });
+      isListening = true;
+    },
+    async close() {
+      if (!isListening)
+        return;
+      server?.stop();
+      server = null;
+      isListening = false;
+      try {
+        await unlink3(socketPath);
+      } catch {}
+    },
+    onMessage(handler) {
+      messageHandler = handler;
+    }
+  };
+}
+function createIpcClient(socketPath) {
+  let socket = null;
+  let isConnected = false;
+  const pendingRequests = new Map;
+  let messageBuffer = "";
+  function generateId() {
+    return `${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+  }
+  function processBuffer() {
+    const lines = messageBuffer.split(`
+`);
+    messageBuffer = lines.pop() ?? "";
+    for (const line of lines) {
+      if (!line.trim())
+        continue;
+      try {
+        const message = JSON.parse(line);
+        const pending = pendingRequests.get(message.id);
+        if (pending) {
+          pendingRequests.delete(message.id);
+          if (message.type === "response") {
+            pending.resolve(message.payload);
+          } else if (message.type === "error") {
+            const errorPayload = message.payload;
+            pending.reject(new Error(errorPayload.message));
+          }
+        }
+      } catch {}
+    }
+  }
+  function rejectAllPending() {
+    for (const [id, pending] of pendingRequests) {
+      pending.reject(new Error("Connection closed"));
+      pendingRequests.delete(id);
+    }
+  }
+  return {
+    connect() {
+      if (isConnected && socket)
+        return Promise.resolve();
+      messageBuffer = "";
+      return new Promise((resolve, reject) => {
+        try {
+          Bun.connect({
+            unix: socketPath,
+            socket: {
+              data(_socket, data) {
+                const text = Buffer.isBuffer(data) ? data.toString("utf-8") : String(data);
+                messageBuffer += text;
+                processBuffer();
+              },
+              open(_socket) {
+                isConnected = true;
+                socket = _socket;
+                resolve();
+              },
+              close() {
+                isConnected = false;
+                socket = null;
+                rejectAllPending();
+              },
+              error(_socket, error) {
+                isConnected = false;
+                socket = null;
+                reject(error);
+              },
+              connectError(_socket, error) {
+                isConnected = false;
+                socket = null;
+                reject(error);
+              }
+            }
+          });
+        } catch (error) {
+          reject(error);
+        }
+      });
+    },
+    send(message) {
+      if (!(isConnected && socket)) {
+        return Promise.reject(new Error("Not connected to server"));
+      }
+      const id = generateId();
+      const request = {
+        id,
+        type: "request",
+        payload: message
+      };
+      return new Promise((resolve, reject) => {
+        pendingRequests.set(id, {
+          resolve,
+          reject
+        });
+        try {
+          const written = socket?.write(`${JSON.stringify(request)}
+`);
+          if (written === 0) {
+            pendingRequests.delete(id);
+            reject(new Error("Failed to write to socket"));
+          }
+        } catch (error) {
+          pendingRequests.delete(id);
+          reject(error);
+        }
+      });
+    },
+    close() {
+      if (!(isConnected && socket))
+        return;
+      try {
+        socket?.terminate();
+      } catch {}
+      socket = null;
+      isConnected = false;
+      rejectAllPending();
+    }
+  };
+}
+// src/health.ts
+function createHealthChecker(checks) {
+  const registeredChecks = [...checks];
+  const startTime = Date.now();
+  async function runCheck(check) {
+    try {
+      const result = await check.check();
+      if (result.isOk()) {
+        return { healthy: true };
+      }
+      return {
+        healthy: false,
+        message: result.error.message
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        message: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  return {
+    async check() {
+      const results = await Promise.all(registeredChecks.map(async (check) => ({
+        name: check.name,
+        result: await runCheck(check)
+      })));
+      const checksRecord = {};
+      let allHealthy = true;
+      for (const { name, result } of results) {
+        checksRecord[name] = result;
+        if (!result.healthy) {
+          allHealthy = false;
+        }
+      }
+      const uptime = Math.floor((Date.now() - startTime) / 1000);
+      return {
+        healthy: allHealthy,
+        checks: checksRecord,
+        uptime
+      };
+    },
+    register(check) {
+      registeredChecks.push(check);
+    }
+  };
+}
+export {
+  releaseDaemonLock,
+  readLockPid,
+  isUnixPlatform,
+  isProcessAlive,
+  isDaemonAlive,
+  getSocketPath,
+  getPidPath,
+  getLockPath,
+  getDaemonDir,
+  createIpcServer,
+  createIpcClient,
+  createHealthChecker,
+  createDaemon,
+  acquireDaemonLock,
+  StaleSocketError,
+  ProtocolError,
+  LockError,
+  DaemonError,
+  ConnectionTimeoutError,
+  ConnectionRefusedError
+};

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "@outfitter/daemon",
+  "description": "Daemon lifecycle, IPC, and health checks for Outfitter",
+  "version": "0.1.0-rc.1",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "bunup --filter @outfitter/daemon",
+    "lint": "biome lint ./src",
+    "lint:fix": "biome lint --write ./src",
+    "test": "bun test",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "@outfitter/contracts": "workspace:*",
+    "@outfitter/file-ops": "workspace:*",
+    "@outfitter/logging": "workspace:*"
+  },
+  "devDependencies": {
+    "@types/bun": "latest",
+    "typescript": "^5.8.0"
+  },
+  "keywords": [
+    "outfitter",
+    "daemon",
+    "lifecycle",
+    "ipc",
+    "health",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/outfitter-dev/outfitter.git",
+    "directory": "packages/daemon"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}