@outfitter/daemon 0.2.1 → 0.2.2

package/dist/shared/@outfitter/daemon-h536nv4k.d.ts

@@ -0,0 +1,103 @@
+import { LockError } from "./daemon-8tpctdgw";
+import { Result } from "@outfitter/contracts";
+/**
+* Handle returned when a lock is successfully acquired.
+*
+* Must be passed to `releaseDaemonLock` to properly release the lock.
+*/
+interface LockHandle {
+	/** Path to the lock file */
+	readonly lockPath: string;
+	/** PID that owns the lock */
+	readonly pid: number;
+}
+/**
+* Check if a process with the given PID is alive.
+*
+* Uses `process.kill(pid, 0)` which sends no signal but checks
+* if the process exists and is accessible.
+*
+* @param pid - Process ID to check
+* @returns true if process exists and is accessible, false otherwise
+*
+* @example
+* ```typescript
+* if (isProcessAlive(12345)) {
+*   console.log("Process is still running");
+* } else {
+*   console.log("Process has exited");
+* }
+* ```
+*/
+declare function isProcessAlive(pid: number): boolean;
+/**
+* Check if a daemon is alive by reading its lock file.
+*
+* @param lockPath - Path to the daemon lock file
+* @returns true if lock file exists and process is alive, false otherwise
+*
+* @example
+* ```typescript
+* const alive = await isDaemonAlive("/run/user/1000/waymark/daemon.lock");
+* if (!alive) {
+*   // Safe to start a new daemon
+* }
+* ```
+*/
+declare function isDaemonAlive(lockPath: string): Promise<boolean>;
+/**
+* Acquire an exclusive lock for a daemon.
+*
+* Uses a PID file approach compatible with Bun:
+* 1. Check if lock file exists with a valid PID
+* 2. If PID is alive, refuse (daemon already running)
+* 3. If PID is stale or no lock, write our PID atomically
+*
+* @param lockPath - Path to create the lock file
+* @returns Result with LockHandle on success, LockError on failure
+*
+* @example
+* ```typescript
+* const result = await acquireDaemonLock("/run/user/1000/waymark/daemon.lock");
+*
+* if (result.isOk()) {
+*   console.log(`Lock acquired for PID ${result.value.pid}`);
+*   // ... run daemon ...
+*   await releaseDaemonLock(result.value);
+* } else {
+*   console.error(`Failed to acquire lock: ${result.error.message}`);
+* }
+* ```
+*/
+declare function acquireDaemonLock(lockPath: string): Promise<Result<LockHandle, LockError>>;
+/**
+* Release a daemon lock.
+*
+* Removes the lock file only if the PID inside matches the handle.
+* This prevents accidentally removing a lock acquired by another process.
+*
+* @param handle - Lock handle returned from acquireDaemonLock
+*
+* @example
+* ```typescript
+* const result = await acquireDaemonLock(lockPath);
+* if (result.isOk()) {
+*   try {
+*     // ... run daemon ...
+*   } finally {
+*     await releaseDaemonLock(result.value);
+*   }
+* }
+* ```
+*/
+declare function releaseDaemonLock(handle: LockHandle): Promise<void>;
+/**
+* Read the PID from a lock file.
+*
+* @param lockPath - Path to the lock file
+* @returns The PID if valid, undefined otherwise
+*
+* @internal
+*/
+declare function readLockPid(lockPath: string): Promise<number | undefined>;
+export { LockHandle, isProcessAlive, isDaemonAlive, acquireDaemonLock, releaseDaemonLock, readLockPid };

package/dist/shared/@outfitter/daemon-qqn2jpsg.js

@@ -0,0 +1,25 @@
+// @bun
+// packages/daemon/src/errors.ts
+import { TaggedError } from "@outfitter/contracts";
+var StaleSocketErrorBase = TaggedError("StaleSocketError")();
+var ConnectionRefusedErrorBase = TaggedError("ConnectionRefusedError")();
+var ConnectionTimeoutErrorBase = TaggedError("ConnectionTimeoutError")();
+var ProtocolErrorBase = TaggedError("ProtocolError")();
+var LockErrorBase = TaggedError("LockError")();
+
+class StaleSocketError extends StaleSocketErrorBase {
+}
+
+class ConnectionRefusedError extends ConnectionRefusedErrorBase {
+}
+
+class ConnectionTimeoutError extends ConnectionTimeoutErrorBase {
+}
+
+class ProtocolError extends ProtocolErrorBase {
+}
+
+class LockError extends LockErrorBase {
+}
+
+export { StaleSocketError, ConnectionRefusedError, ConnectionTimeoutError, ProtocolError, LockError };

package/dist/shared/@outfitter/daemon-wz4peqjh.js

@@ -0,0 +1,48 @@
+// @bun
+// packages/daemon/src/platform.ts
+import { platform as osPlatform, tmpdir, userInfo } from "os";
+import { join } from "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);
+}
+
+export { isUnixPlatform, getSocketPath, getLockPath, getPidPath, getDaemonDir };

package/dist/types.d.ts

@@ -0,0 +1,2 @@
+import { Daemon, DaemonError, DaemonErrorCode, DaemonOptions, DaemonState, ShutdownHandler } from "./shared/@outfitter/daemon-9w2ey87r";
+export { ShutdownHandler, DaemonState, DaemonOptions, DaemonErrorCode, DaemonError, Daemon };

package/dist/types.js

@@ -0,0 +1,7 @@
+// @bun
+import {
+  DaemonError
+} from "./shared/@outfitter/daemon-dzt3fqvp.js";
+export {
+  DaemonError
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@outfitter/daemon",
   "description": "Daemon lifecycle, IPC, and health checks for Outfitter",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "type": "module",
   "files": [
     "dist"
@@ -15,7 +15,49 @@
         "default": "./dist/index.js"
       }
     },
-    "./package.json": "./package.json"
+    "./errors": {
+      "import": {
+        "types": "./dist/errors.d.ts",
+        "default": "./dist/errors.js"
+      }
+    },
+    "./health": {
+      "import": {
+        "types": "./dist/health.d.ts",
+        "default": "./dist/health.js"
+      }
+    },
+    "./ipc": {
+      "import": {
+        "types": "./dist/ipc.d.ts",
+        "default": "./dist/ipc.js"
+      }
+    },
+    "./lifecycle": {
+      "import": {
+        "types": "./dist/lifecycle.d.ts",
+        "default": "./dist/lifecycle.js"
+      }
+    },
+    "./locking": {
+      "import": {
+        "types": "./dist/locking.d.ts",
+        "default": "./dist/locking.js"
+      }
+    },
+    "./package.json": "./package.json",
+    "./platform": {
+      "import": {
+        "types": "./dist/platform.d.ts",
+        "default": "./dist/platform.js"
+      }
+    },
+    "./types": {
+      "import": {
+        "types": "./dist/types.d.ts",
+        "default": "./dist/types.js"
+      }
+    }
   },
   "sideEffects": false,
   "scripts": {
@@ -27,9 +69,9 @@
     "clean": "rm -rf dist"
   },
   "dependencies": {
-    "@outfitter/contracts": "0.2.0",
-    "@outfitter/file-ops": "0.2.0",
-    "@outfitter/logging": "0.3.0"
+    "@outfitter/contracts": "0.3.0",
+    "@outfitter/file-ops": "0.2.1",
+    "@outfitter/logging": "0.4.0"
   },
   "devDependencies": {
     "@types/bun": "latest",