@relayfile/client 0.10.27-rc.0 → 0.10.28

package/dist/client.d.ts

@@ -78,6 +78,7 @@ export declare class RelayfileControlPlaneClient {
     private readonly requestTimeoutMs;
     private ready;
     constructor(options?: RelayfileClientOptions);
+    private createHTTPRequest;
     /** Low-level request over the unix socket. Throws RelayfileControlPlaneError. */
     private rawRequest;
     /** Connect (auto-starting the daemon if configured), version-negotiating once. */
@@ -86,6 +87,9 @@ export declare class RelayfileControlPlaneClient {
     private spawnDaemon;
     private startDaemonAndConnect;
     private stopStaleDaemon;
+    private socketOwnerPids;
+    /** Resolve a Unix-socket owner without external tools on standard Linux hosts. */
+    private linuxSocketOwnerPids;
     private versionMismatchError;
     private versionRejectionError;
     private restartCommand;

package/dist/client.js

@@ -1,6 +1,6 @@
 import { spawn } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { request } from 'node:http';
+import { existsSync, readFileSync, readdirSync, readlinkSync } from 'node:fs';
+import { request, } from 'node:http';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 /**
@@ -82,7 +82,15 @@ export class RelayfileControlPlaneError extends Error {
     }
 }
 const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
-const TRANSIENT_CONNECTION_CODES = new Set(['ENOENT', 'ECONNREFUSED', 'ETIMEDOUT']);
+const TRANSIENT_CONNECTION_CODES = new Set([
+    'ENOENT',
+    'ECONNREFUSED',
+    'ETIMEDOUT',
+    // A daemon that binds the socket before it is ready to serve can accept and
+    // then drop the connection mid-request; both surface during startup polling.
+    'ECONNRESET',
+    'EPIPE',
+]);
 function isTransientConnectionCode(code) {
     return code != null && TRANSIENT_CONNECTION_CODES.has(code);
 }
@@ -106,6 +114,9 @@ export class RelayfileControlPlaneClient {
         this.startTimeoutMs = options.startTimeoutMs ?? 5000;
         this.requestTimeoutMs = options.requestTimeoutMs ?? 10000;
     }
+    createHTTPRequest(options, onResponse) {
+        return request(options, onResponse);
+    }
     /** Low-level request over the unix socket. Throws RelayfileControlPlaneError. */
     rawRequest(opts) {
         const query = opts.query
@@ -130,7 +141,7 @@ export class RelayfileControlPlaneClient {
                 settled = true;
                 resolve(value);
             };
-            const req = request({
+            const req = this.createHTTPRequest({
                 socketPath: this.socketPath,
                 method: opts.method,
                 path,
@@ -300,13 +311,7 @@ export class RelayfileControlPlaneClient {
             `(${lastErr instanceof Error ? lastErr.message : String(lastErr)}).`);
     }
     async stopStaleDaemon() {
-        const result = await this.runCommand('lsof', ['-t', '--', this.socketPath], 1000);
-        const pids = [
-            ...new Set((result?.code === 0 ? result.stdout : '')
-                .split(/\s+/)
-                .map((value) => Number.parseInt(value, 10))
-                .filter((pid) => Number.isSafeInteger(pid) && pid > 1 && pid !== process.pid)),
-        ];
+        const pids = await this.socketOwnerPids();
         if (pids.length !== 1) {
             throw new Error(pids.length === 0
                 ? `could not identify the process serving ${this.socketPath}`
@@ -326,6 +331,83 @@ export class RelayfileControlPlaneClient {
             throw new Error(`stale relayfile control-plane pid ${pids[0]} did not release ${this.socketPath} within ${this.startTimeoutMs}ms`);
         }
     }
+    async socketOwnerPids() {
+        if (process.platform === 'linux') {
+            const procPids = this.linuxSocketOwnerPids();
+            if (procPids.length > 0)
+                return procPids;
+        }
+        if (process.platform === 'win32') {
+            throw new Error('automatic stale-daemon replacement is not supported on Windows; stop the running relayfile control-plane manually');
+        }
+        const result = await this.runCommand('lsof', ['-t', '--', this.socketPath], 1000);
+        if (!result) {
+            throw new Error(`could not run \`lsof\` to identify the process serving ${this.socketPath} ` +
+                `(it is not installed, not on PATH, or did not exit within 1000ms); ` +
+                `install lsof or stop the stale relayfile control-plane manually`);
+        }
+        if (result.code !== 0) {
+            throw new Error(`lsof could not identify the process serving ${this.socketPath} (exit ${result.code}${result.stderr.trim() ? `: ${result.stderr.trim()}` : ''})`);
+        }
+        return [
+            ...new Set(result.stdout
+                .split(/\s+/)
+                .map((value) => Number.parseInt(value, 10))
+                .filter((pid) => Number.isSafeInteger(pid) && pid > 1 && pid !== process.pid)),
+        ];
+    }
+    /** Resolve a Unix-socket owner without external tools on standard Linux hosts. */
+    linuxSocketOwnerPids(procRoot = '/proc') {
+        let socketInodes;
+        try {
+            socketInodes = new Set(readFileSync(join(procRoot, 'net', 'unix'), 'utf8')
+                .split('\n')
+                .slice(1)
+                .map((line) => line.trim().split(/\s+/))
+                .filter((fields) => fields.length >= 8 && fields.slice(7).join(' ') === this.socketPath)
+                .map((fields) => fields[6]));
+        }
+        catch {
+            return [];
+        }
+        if (socketInodes.size === 0)
+            return [];
+        const pids = new Set();
+        let processes;
+        try {
+            processes = readdirSync(procRoot).filter((name) => /^\d+$/.test(name));
+        }
+        catch {
+            return [];
+        }
+        for (const processName of processes) {
+            const pid = Number.parseInt(processName, 10);
+            if (pid <= 1 || pid === process.pid)
+                continue;
+            const fdDir = join(procRoot, processName, 'fd');
+            let descriptors;
+            try {
+                descriptors = readdirSync(fdDir);
+            }
+            catch {
+                continue;
+            }
+            for (const descriptor of descriptors) {
+                try {
+                    const target = readlinkSync(join(fdDir, descriptor));
+                    const inode = target.match(/^socket:\[(\d+)\]$/)?.[1];
+                    if (inode && socketInodes.has(inode)) {
+                        pids.add(pid);
+                        break;
+                    }
+                }
+                catch {
+                    // File descriptors may disappear while /proc is scanned.
+                }
+            }
+        }
+        return [...pids];
+    }
     versionMismatchError(hello, installedVersion, detail) {
         const supported = hello.supportedApiVersions?.length
             ? hello.supportedApiVersions.map((version) => `v${version}`).join(', ')

package/dist/generated/control-plane.d.ts

@@ -14,6 +14,9 @@ export interface paths {
          * Negotiate control-plane API compatibility
          * @description Unversioned discovery endpoint. The daemon always returns its current
          *     and supported API versions; any version header or query is ignored.
+         *     No version parameters are declared here on purpose: discovery must stay
+         *     callable by clients of any API version, including versions this contract
+         *     does not know about.
          */
         get: operations["hello"];
         put?: never;
@@ -370,7 +373,6 @@ export interface components {
     };
     parameters: {
         ApiVersionHeader: 3;
-        ApiVersionQuery: number;
     };
     requestBodies: never;
     headers: never;
@@ -380,12 +382,8 @@ export type $defs = Record<string, never>;
 export interface operations {
     hello: {
         parameters: {
-            query?: {
-                apiVersion?: components["parameters"]["ApiVersionQuery"];
-            };
-            header?: {
-                "X-Relayfile-API-Version"?: components["parameters"]["ApiVersionHeader"];
-            };
+            query?: never;
+            header?: never;
             path?: never;
             cookie?: never;
         };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@relayfile/client",
-  "version": "0.10.27-rc.0",
+  "version": "0.10.28",
   "description": "Typed client for the relayfile local control-plane (unix-socket HTTP/JSON), generated from the authoritative OpenAPI contract",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",