@bendyline/gezel-inference 1.0.7 → 1.0.9

package/dist/runtime-lock.js

@@ -1,6 +1,6 @@
-import { readFileSync, readlinkSync } from 'node:fs';
 import { mkdir, open, readFile, rm, stat, utimes } from 'node:fs/promises';
-import { hostname as osHostname } from 'node:os';
+import { LOCK_HEARTBEAT_INTERVAL_MS, LOCK_STALE_AFTER_MS, currentLockIdentity, foreignHolderMessage, parseLockFile, procStartTicks, sharesPidNamespace, } from '@bendyline/gezel/native';
+export { currentLockIdentity, parseLockFile, procStartTicks, sharesPidNamespace };
 /**
  * Thrown when a gezel home already has a live daemon. The CLI's `gezel
  * start` / the supervisor surface this as an actionable message rather
@@ -12,7 +12,7 @@ export class SingleInstanceError extends Error {
     holderHost;
     constructor(holderPid, lockPath, holderHost) {
         super(holderHost !== undefined
-            ? `Another Gezel daemon (host "${holderHost}", pid ${holderPid}) is using this home. If it runs in a container, run commands inside that container with \`docker exec <container> gezel …\` instead of starting a second container on the same volume.`
+            ? foreignHolderMessage({ pid: holderPid, hostname: holderHost })
             : holderPid > 0
                 ? `Another gezel daemon is already running for this home (pid ${holderPid}). Stop it first with \`gezel stop\`, or use a different GEZEL_HOME.`
                 : `Could not acquire the single-instance lock at ${lockPath}.`);
@@ -22,8 +22,8 @@ export class SingleInstanceError extends Error {
         this.name = 'SingleInstanceError';
     }
 }
-const HEARTBEAT_INTERVAL_MS = 10_000;
-const STALE_AFTER_MS = 40_000;
+// A holder's identity (core's lock-identity.ts) is what let a one-shot
+// `docker run … gezel do` stop reclaiming a serving container's live lock.
 function defaultIsAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -35,45 +35,6 @@ function defaultIsAlive(pid) {
         return err.code === 'EPERM';
     }
 }
-function readTrimmed(path) {
-    try {
-        return readFileSync(path, 'utf8').trim() || undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-export function procStartTicks(pid) {
-    if (process.platform !== 'linux')
-        return undefined;
-    const stat = readTrimmed(`/proc/${pid}/stat`);
-    if (!stat)
-        return undefined;
-    // comm (field 2) may contain spaces and parentheses; fields resume after
-    // the last ')'. starttime is field 22 overall, the 20th after comm.
-    const rest = stat.slice(stat.lastIndexOf(')') + 2).split(' ');
-    return rest[19];
-}
-export function currentLockIdentity() {
-    const linux = process.platform === 'linux';
-    let pidNs;
-    if (linux) {
-        try {
-            pidNs = readlinkSync('/proc/self/ns/pid');
-        }
-        catch {
-            pidNs = undefined;
-        }
-    }
-    return {
-        pid: process.pid,
-        hostname: osHostname(),
-        bootId: linux ? readTrimmed('/proc/sys/kernel/random/boot_id') : undefined,
-        pidNs,
-        startTicks: procStartTicks('self'),
-        instance: `${process.pid}-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`,
-    };
-}
 /**
  * The pid stays on the first line so a daemon from before the identity
  * record (which parses the leading integer) still reads it as held instead
@@ -82,29 +43,6 @@ export function currentLockIdentity() {
 function serializeIdentity(identity) {
     return `${identity.pid}\n${JSON.stringify({ v: 1, ...identity })}\n`;
 }
-export function parseLockFile(text) {
-    const [first, second] = text.split('\n');
-    const pid = Number.parseInt((first ?? '').trim(), 10);
-    if (!Number.isFinite(pid))
-        return null;
-    if (!second?.trim())
-        return { pid };
-    try {
-        const record = JSON.parse(second);
-        const text = (value) => (typeof value === 'string' && value ? value : undefined);
-        return {
-            pid,
-            hostname: text(record.hostname),
-            bootId: text(record.bootId),
-            pidNs: text(record.pidNs),
-            startTicks: text(record.startTicks),
-            instance: text(record.instance),
-        };
-    }
-    catch {
-        return { pid };
-    }
-}
 async function readHolder(lockPath) {
     try {
         return parseLockFile(await readFile(lockPath, 'utf8'));
@@ -113,17 +51,6 @@ async function readHolder(lockPath) {
         return null;
     }
 }
-/**
- * Whether a pid check against `holder` means anything here. Any field the
- * holder recorded must match ours; a legacy pid-only record is assumed to be
- * in our namespace, which is how it was judged before.
- */
-export function sharesPidNamespace(holder, me) {
-    const same = (a, b) => !a || !b || a === b;
-    return (same(holder.hostname, me.hostname) &&
-        same(holder.bootId, me.bootId) &&
-        same(holder.pidNs, me.pidNs));
-}
 async function lockMtimeMs(lockPath) {
     try {
         return (await stat(lockPath)).mtimeMs;
@@ -174,7 +101,7 @@ export async function acquireSingleInstanceLock(opts) {
     const startTicksOf = opts.startTicksOf ?? procStartTicks;
     const now = opts.now ?? Date.now;
     const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
-    const staleAfterMs = opts.staleAfterMs ?? STALE_AFTER_MS;
+    const staleAfterMs = opts.staleAfterMs ?? LOCK_STALE_AFTER_MS;
     await mkdir(opts.runtimeDir, { recursive: true });
     for (let attempt = 0; attempt < 3; attempt++) {
         try {
@@ -185,7 +112,7 @@ export async function acquireSingleInstanceLock(opts) {
             finally {
                 await handle.close();
             }
-            return holdLock(opts.lockPath, me, opts.heartbeatIntervalMs ?? HEARTBEAT_INTERVAL_MS);
+            return holdLock(opts.lockPath, me, opts.heartbeatIntervalMs ?? LOCK_HEARTBEAT_INTERVAL_MS);
         }
         catch (err) {
             if (err.code !== 'EEXIST')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bendyline/gezel-inference",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Gezel's on-device inference runtime: native engines, local model management, embeddings, knowledge search, and OpenAI-compatible routes.",
   "license": "MIT",
   "keywords": [
@@ -73,9 +73,9 @@
     "!dist/**/__pycache__"
   ],
   "dependencies": {
-    "@bendyline/gezel": "1.2.12",
-    "@bendyline/gezel-catalog": "1.2.12",
-    "@bendyline/gezel-client": "1.2.12",
+    "@bendyline/gezel": "1.2.14",
+    "@bendyline/gezel-catalog": "1.2.14",
+    "@bendyline/gezel-client": "1.2.14",
     "@bendyline/gezel-knowledge": "1.2.10",
     "hono": "4.13.14",
     "tar": "7.5.21",