omnius 1.0.728 → 1.0.729

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 38123753 bytes
-sha256: e049258d999f7d4d056e6d5c2f2adade3356a8c217233909bd1b60ca6f35be27
+size: 38125885 bytes
+sha256: 389fd56947773740b14ff60a2d67211d846b6d332df43bcbefb49c354341b54a

package/dist/update-worker.js

@@ -296100,21 +296100,32 @@ async function repairManagedDaemonUnit(port, preferredEntrypoint) {
     return false;
   }
 }
-async function portHolderPids(port) {
+function daemonListenerLsofArgs(port) {
+  return ["-nP", "-t", "-a", `-iTCP:${port}`, "-sTCP:LISTEN"];
+}
+function parsePidList(output) {
+  return output.split(/[\s\n]+/).map((value) => parseInt(value, 10)).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+}
+function parseSsListenerPids(output) {
+  return [...output.matchAll(/\bpid=(\d+)\b/g)].map((match2) => parseInt(match2[1], 10)).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+}
+async function daemonListenerPids(port, dependencies = { run: runUtilityCommand }) {
   try {
-    const lsof = await runUtilityCommand("lsof", ["-ti", `:${port}`], 3e3);
-    let output = lsof.stdout;
-    if (!output.trim()) {
-      const fuser = await runUtilityCommand("fuser", [`${port}/tcp`], 3e3);
-      output = `${fuser.stdout}
-${fuser.stderr}`;
-      if (!lsof.available && !fuser.available) return null;
+    const lsof = await dependencies.run("lsof", daemonListenerLsofArgs(port), 3e3);
+    if (lsof.available && (lsof.code === 0 || lsof.code === 1)) {
+      return [...new Set(parsePidList(lsof.stdout))];
     }
-    return output.split(/[\s\n]+/).map((value) => parseInt(value, 10)).filter((pid) => Number.isInteger(pid) && pid > 0 && pid !== process.pid);
+    const ss = await dependencies.run("ss", ["-H", "-ltnp", `sport = :${port}`], 3e3);
+    if (!ss.available || ss.code !== 0) return null;
+    const pids = [...new Set(parseSsListenerPids(ss.stdout))];
+    return ss.stdout.trim() && pids.length === 0 ? null : pids;
   } catch {
     return null;
   }
 }
+async function portHolderPids(port) {
+  return daemonListenerPids(port);
+}
 async function daemonPortIsFree(port) {
   return new Promise((resolve10) => {
     const probe = createNetServer();
@@ -296135,8 +296146,7 @@ async function daemonPortIsFree(port) {
 async function waitForDaemonStopped(port, attempts = DAEMON_GRACEFUL_STOP_ATTEMPTS) {
   for (let attempt = 0; attempt < attempts; attempt++) {
     const healthy = await isDaemonRunning(port);
-    const holders = await portHolderPids(port);
-    const portFree = holders === null ? await daemonPortIsFree(port) : holders.length === 0;
+    const portFree = await daemonPortIsFree(port);
     if (!healthy && portFree) return true;
     await delay(500);
   }
@@ -296152,42 +296162,44 @@ var DEFAULT_RECLAIM_DEPENDENCIES = {
   }),
   waitForFree: (port) => waitForDaemonStopped(port)
 };
-async function reclaimStaleDaemonEndpointClaim(port) {
+function removeDaemonLockIfUnchanged(port, expected) {
   const lockFile = daemonLockFile(port);
-  const record = readDaemonLock(lockFile);
-  if (!record) return true;
-  if (!await daemonPortIsFree(port)) return true;
-  if (!processIsAlive(record.pid)) {
-    const current2 = readDaemonLock(lockFile);
-    if (current2?.pid === record.pid && current2.token === record.token) {
-      try {
-        unlinkSync2(lockFile);
-      } catch {
-      }
-    }
+  const current = readDaemonLock(lockFile);
+  if (!current) return true;
+  if (current.pid !== expected.pid || current.token !== expected.token) return false;
+  try {
+    unlinkSync2(lockFile);
     return true;
+  } catch (error) {
+    return error.code === "ENOENT";
   }
-  const lease = listProcessLeases({ includeInactive: false }).find(
+}
+var DEFAULT_CLAIM_RECLAIM_DEPENDENCIES = {
+  readLock: (port) => readDaemonLock(daemonLockFile(port)),
+  portIsFree: (port) => daemonPortIsFree(port),
+  processIsAlive: (pid) => processIsAlive(pid),
+  leases: () => listProcessLeases({ includeInactive: false }),
+  stopLease: (leaseId, port) => stopProcessLease(leaseId, {
+    reason: `stale daemon endpoint claim on port ${port}`,
+    termGraceMs: 1e3
+  }),
+  removeLockIfUnchanged: (port, expected) => removeDaemonLockIfUnchanged(port, expected)
+};
+async function reclaimStaleDaemonEndpointClaim(port, verifiedStoppedPids = /* @__PURE__ */ new Set(), dependencies = DEFAULT_CLAIM_RECLAIM_DEPENDENCIES) {
+  const record = dependencies.readLock(port);
+  if (!record) return dependencies.portIsFree(port);
+  if (!await dependencies.portIsFree(port)) return false;
+  const clearExactClaim = async () => dependencies.removeLockIfUnchanged(port, record) && dependencies.portIsFree(port);
+  if (verifiedStoppedPids.has(record.pid) || !dependencies.processIsAlive(record.pid)) {
+    return clearExactClaim();
+  }
+  const lease = dependencies.leases().find(
     (item) => item.status === "active" && item.pid === record.pid && item.ownerKind === "daemon" && item.ownerId === `daemon:${port}`
   );
   if (!lease) return false;
-  const stopped = await stopProcessLease(lease.leaseId, {
-    reason: `stale daemon endpoint claim on port ${port}`,
-    termGraceMs: 1e3
-  });
+  const stopped = await dependencies.stopLease(lease.leaseId, port);
   if (stopped.action !== "killed" && stopped.action !== "dead") return false;
-  for (let attempt = 0; attempt < 20 && processIsAlive(record.pid); attempt++) {
-    await delay(100);
-  }
-  if (processIsAlive(record.pid)) return false;
-  const current = readDaemonLock(lockFile);
-  if (current?.pid === record.pid && current.token === record.token) {
-    try {
-      unlinkSync2(lockFile);
-    } catch {
-    }
-  }
-  return daemonPortIsFree(port);
+  return clearExactClaim();
 }
 async function reclaimOwnedDaemonListener(port = getDaemonPort(), dependencies = DEFAULT_RECLAIM_DEPENDENCIES) {
   const holders = await dependencies.holderPids(port);
@@ -296269,9 +296281,9 @@ async function restartDaemon(port, expectedVersion, preferredEntrypoint) {
   const managed = await managedDaemonServiceMatchesPort(p);
   if (managed) {
     if (!await managedDaemonServiceOwnsPort(p)) {
-      const reclaimed = await reclaimOwnedDaemonListener(p);
-      if (!reclaimed.ok) return false;
-      await reclaimStaleDaemonEndpointClaim(p);
+      const reclaimed2 = await reclaimOwnedDaemonListener(p);
+      if (!reclaimed2.ok) return false;
+      await reclaimStaleDaemonEndpointClaim(p, new Set(reclaimed2.clearedPids));
     }
     await runUserSystemctl(["reset-failed", "omnius-daemon.service"]);
     const restarted = await runUserSystemctl(["restart", "omnius-daemon.service"]);
@@ -296286,15 +296298,13 @@ async function restartDaemon(port, expectedVersion, preferredEntrypoint) {
     }
     await runUserSystemctl(["stop", "omnius-daemon.service"]);
     if (!await waitForDaemonStopped(p)) {
-      const reclaimed = await reclaimOwnedDaemonListener(p);
-      if (!reclaimed.ok) return false;
+      const reclaimed2 = await reclaimOwnedDaemonListener(p);
+      if (!reclaimed2.ok) return false;
     }
   }
-  if (await isDaemonRunning(p)) {
-    const reclaimed = await reclaimOwnedDaemonListener(p);
-    if (!reclaimed.ok) return false;
-  }
-  if (!await reclaimStaleDaemonEndpointClaim(p)) return false;
+  const reclaimed = await reclaimOwnedDaemonListener(p);
+  if (!reclaimed.ok) return false;
+  if (!await reclaimStaleDaemonEndpointClaim(p, new Set(reclaimed.clearedPids))) return false;
   const pid = await startDaemon(p, preferredEntrypoint);
   if (!pid) return false;
   return (await waitForDaemonReady(p, expectedVersion)).ok;
@@ -296404,25 +296414,27 @@ async function startDaemon(port = getDaemonPort(), preferredEntrypoint) {
     }
   }
 }
-async function stopDaemonAtPort(port = getDaemonPort()) {
-  if (await managedDaemonServiceMatchesPort(port)) {
-    const stopped = await runUserSystemctl(["stop", "omnius-daemon.service"]);
-    if (stopped.ok && await waitForDaemonStopped(port)) return true;
+var DEFAULT_DAEMON_STOP_DEPENDENCIES = {
+  managedServiceMatchesPort: (port) => managedDaemonServiceMatchesPort(port),
+  stopManagedService: async () => (await runUserSystemctl(["stop", "omnius-daemon.service"])).ok,
+  waitForStopped: (port) => waitForDaemonStopped(port),
+  reclaimListener: (port) => reclaimOwnedDaemonListener(port),
+  reclaimClaim: (port, verifiedStoppedPids) => reclaimStaleDaemonEndpointClaim(port, verifiedStoppedPids)
+};
+async function stopDaemonAtPort(port = getDaemonPort(), dependencies = DEFAULT_DAEMON_STOP_DEPENDENCIES) {
+  if (await dependencies.managedServiceMatchesPort(port)) {
+    const stopped = await dependencies.stopManagedService();
+    if (stopped && await dependencies.waitForStopped(port)) return true;
   }
-  const wasRunning = await isDaemonRunning(port);
-  const reclaimed = await reclaimOwnedDaemonListener(port);
+  const reclaimed = await dependencies.reclaimListener(port);
   if (!reclaimed.ok) return false;
-  const claimCleared = await reclaimStaleDaemonEndpointClaim(port);
-  return claimCleared && (wasRunning || reclaimed.action === "cleared");
+  const claimCleared = await dependencies.reclaimClaim(
+    port,
+    new Set(reclaimed.clearedPids)
+  );
+  return claimCleared && dependencies.waitForStopped(port);
 }
 async function quiesceDaemonForUpdate(port = getDaemonPort()) {
-  if (await managedDaemonServiceMatchesPort(port)) {
-    const stopped = await runUserSystemctl(["stop", "omnius-daemon.service"]);
-    if (stopped.ok && await waitForDaemonStopped(port)) return true;
-  }
-  if (!await isDaemonRunning(port)) {
-    return daemonPortIsFree(port);
-  }
   return stopDaemonAtPort(port);
 }
 
@@ -296662,6 +296674,19 @@ function transition(current, patch, paths) {
 function permissionRemediation(evidence) {
   return /EACCES|EPERM|permission denied/i.test(evidence) ? "The discovered npm global prefix is not writable. Configure a user-owned npm prefix or rerun the explicit update from a privileged terminal; Omnius never silently elevates." : void 0;
 }
+async function quiesceDaemonWithRetry(quiesce, attempts = 3, pauseMs = 250) {
+  const boundedAttempts = Math.max(1, Math.min(5, Math.floor(attempts)));
+  for (let attempt = 1; attempt <= boundedAttempts; attempt++) {
+    try {
+      if (await quiesce()) return true;
+    } catch {
+    }
+    if (attempt < boundedAttempts && pauseMs > 0) {
+      await new Promise((resolve10) => setTimeout(resolve10, pauseMs));
+    }
+  }
+  return false;
+}
 function installGlobalPackageStreaming(input) {
   return new Promise((resolve10) => {
     const stderrTail = [];
@@ -296740,7 +296765,7 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
   try {
     if (dependencies.quiesceDaemon) {
       state = transition(state, { phase: "daemon_quiescing" }, paths);
-      if (!await dependencies.quiesceDaemon()) {
+      if (!await quiesceDaemonWithRetry(dependencies.quiesceDaemon)) {
         throw new Error(
           `Could not safely stop the daemon at ${state.daemon_endpoint ?? "the configured endpoint"} before updating`
         );

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "omnius",
-  "version": "1.0.728",
+  "version": "1.0.729",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "omnius",
-      "version": "1.0.728",
+      "version": "1.0.729",
       "bundleDependencies": [
         "image-to-ascii"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnius",
-  "version": "1.0.728",
+  "version": "1.0.729",
   "description": "AI coding agent powered by open-source models (Ollama/vLLM) — interactive TUI with agentic tool-calling loop",
   "type": "module",
   "main": "./dist/library.js",