@procedures/peer 0.10.0 → 0.12.0

package/src/index.ts

@@ -26,8 +26,44 @@ export type {
   ProcedureUpdateMessage,
 } from "./types.js";
 
-// Peer
-export { createPeer, type Peer, type PeerOptions, type PeerEndpoint } from "./peer/index.js";
+// The procedures host (CLI-7): the parts of a service, and its faces
+export {
+  createProcedureHost,
+  httpFace,
+  wsFace,
+  LOCAL_LISTENER_KNOBS,
+  callOperations,
+  faceHandler,
+  operationOfCall,
+} from "./host/index.js";
+export type {
+  ProcedureHost,
+  ProcedureHostOptions,
+  ProcedureHostFaces,
+  HostListener,
+  HostCollection,
+  HostServerOptions,
+  HostPart,
+  HostDependency,
+  HostCheck,
+  HostPattern,
+  HostController,
+  HostEndpoint,
+  HostInfo,
+  HostKnobs,
+  HostFace,
+  HostFaceContext,
+  HostFaceEndpoint,
+  HostFaceFactory,
+  HostFaceUpgrade,
+  CallDetail,
+  CallOperation,
+  FaceHandler,
+  FaceHandlerOptions,
+} from "./host/index.js";
+
+// Peer: a procedures host with a service of its own, for a process that has no service
+export { createPeer, peerHostOptions, PEER_PROFILE, type Peer, type PeerOptions, type PeerEndpoint } from "./peer/index.js";
 export { exposeRule } from "./expose.js";
 
 // Procedures

package/src/lockfile.ts

@@ -5,7 +5,8 @@
  * the build of `mark` and its peer id. Before, five copies of this logic had drifted, and a
  * server counted as alive when its PID existed: Windows reuses PIDs, so a stale lockfile broke
  * every `mark` command and `server stop` killed an unrelated process (deep dive CLI-4). Now a
- * server is alive only when its health endpoint answers with the peer id of its lockfile.
+ * server is alive only when its procedure `host.info` answers the token of its lockfile with the
+ * peer id of its lockfile.
  */
 
 import * as fs from "node:fs";
@@ -53,6 +54,30 @@ export function writeLockfile(data: LockfileData): void {
   fs.writeFileSync(lockfilePath(data.port), JSON.stringify(data, null, 2), { mode: 0o600 });
 }
 
+/** A lockfile as a dependency of a service: the shape of `DependencyHandle` of `@mark1russell7/service`. */
+export interface LockfileHandle {
+  /** This method writes the lockfile. */
+  connect(): void;
+  /** This method removes the lockfile, when it is still the lockfile of this host. */
+  close(): void;
+}
+
+/**
+ * This function gives the lockfile of a host as a dependency of its service (CLI-8). The lifecycle
+ * connects the dependencies before the listeners start, and it closes them after the listeners
+ * close. Thus the stages of `run()` own the lockfile, and the entry has no signal handler for it.
+ * The close leaves a lockfile of another peer on the same port.
+ */
+export function lockfileHandle(data: LockfileData): LockfileHandle {
+  return {
+    connect: () => writeLockfile(data),
+    close: () => {
+      const current = readLockfileForPort(data.port);
+      if (current === null || current.peerId === data.peerId) removeLockfileForPort(data.port);
+    },
+  };
+}
+
 export function readLockfileForPort(port: number): LockfileData | null {
   try {
     return JSON.parse(fs.readFileSync(lockfilePath(port), "utf-8")) as LockfileData;
@@ -95,21 +120,28 @@ export function removeLockfileForPort(port: number): void {
 }
 
 /**
- * The state of a lockfile's server:
- * - "alive": the health endpoint answers with the lockfile's peer id;
+ * The state of a lockfile's server, from the procedure `host.info` with the token of the lockfile
+ * (CLI-7, CLI-9). Before, the server answered a `/health` route without the token, and that route said
+ * "ok" also while the server stopped.
+ * - "alive": `host.info` answers with the lockfile's peer id;
  * - "dead": nothing answers (the lockfile is stale);
- * - "other": something else answers on the port (another server, or a lockfile without a peer id).
+ * - "other": something else answers on the port (another server, a refused token, or a lockfile without a peer id).
  */
 export async function checkServer(lockfile: LockfileData, timeoutMs = 1000): Promise<"alive" | "dead" | "other"> {
   let response: Response;
   try {
-    response = await fetch(`${lockfile.endpoint}/health`, { signal: AbortSignal.timeout(timeoutMs) });
+    response = await fetch(`${lockfile.endpoint}/host/info`, {
+      method: "POST",
+      headers: { "content-type": "application/json", ...(lockfile.token !== undefined ? { authorization: `Bearer ${lockfile.token}` } : {}) },
+      body: "{}",
+      signal: AbortSignal.timeout(timeoutMs),
+    });
   } catch {
     return "dead";
   }
   try {
-    const health = (await response.json()) as { peerId?: unknown };
-    return lockfile.peerId !== undefined && health.peerId === lockfile.peerId ? "alive" : "other";
+    const info = (await response.json()) as { peerId?: unknown };
+    return response.ok && lockfile.peerId !== undefined && info.peerId === lockfile.peerId ? "alive" : "other";
   } catch {
     return "other";
   }