omnius 1.0.598 → 1.0.599

package/dist/index.js

@@ -678083,6 +678083,7 @@ __export(daemon_exports, {
   getDaemonStatus: () => getDaemonStatus,
   getLocalCliVersion: () => getLocalCliVersion,
   isDaemonRunning: () => isDaemonRunning,
+  reclaimOwnedDaemonListener: () => reclaimOwnedDaemonListener,
   recoverDaemonVersionBoundedly: () => recoverDaemonVersionBoundedly,
   releaseDaemonEndpointClaim: () => releaseDaemonEndpointClaim,
   releaseDaemonEndpointForCurrentProcess: () => releaseDaemonEndpointForCurrentProcess,
@@ -678094,6 +678095,7 @@ import { spawn as spawn28 } from "node:child_process";
 import { existsSync as existsSync116, readFileSync as readFileSync94, writeFileSync as writeFileSync60, mkdirSync as mkdirSync69, unlinkSync as unlinkSync22, openSync as openSync4, closeSync as closeSync4, writeSync as writeSync3, statSync as statSync46, renameSync as renameSync17 } from "node:fs";
 import { join as join128 } from "node:path";
 import { homedir as homedir39 } from "node:os";
+import { createServer as createNetServer } from "node:net";
 import { fileURLToPath as fileURLToPath18 } from "node:url";
 import { dirname as dirname42 } from "node:path";
 function getDaemonPort() {
@@ -678353,55 +678355,105 @@ ${fuser.stderr ?? ""}`;
     return null;
   }
 }
-function processCommandLine(pid) {
-  try {
-    return readFileSync94(`/proc/${pid}/cmdline`, "utf8").replace(/\0/g, " ");
-  } catch {
-    return "";
-  }
-}
-function isOwnedOmniusDaemon(pid, daemonPid) {
-  if (pid === daemonPid) return true;
-  if (listProcessLeases({ includeInactive: false }).some((lease) => lease.pid === pid && lease.ownerKind === "daemon")) {
-    return true;
-  }
-  const command = processCommandLine(pid);
-  return /(?:^|[\\/\s])omnius(?:[\\/\s]|$)|omnius-daemon|[\\/]dist[\\/]index\.js\b|launcher\.cjs\b/i.test(command);
-}
-async function ownedDaemonPids(port) {
-  const daemonPid = getDaemonPid();
-  const candidates = /* @__PURE__ */ new Set();
-  if (daemonPid) candidates.add(daemonPid);
-  const holders = await portHolderPids(port);
-  for (const pid of holders ?? []) candidates.add(pid);
-  return [...candidates].filter((pid) => processIsAlive(pid) && isOwnedOmniusDaemon(pid, daemonPid));
+async function daemonPortIsFree(port) {
+  return new Promise((resolve87) => {
+    const probe = createNetServer();
+    let settled = false;
+    const finish = (free) => {
+      if (settled) return;
+      settled = true;
+      resolve87(free);
+    };
+    probe.once("error", () => finish(false));
+    probe.once("listening", () => {
+      probe.close(() => finish(true));
+    });
+    probe.listen(port, "127.0.0.1");
+    probe.unref();
+  });
 }
 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);
-    if (!healthy && (holders === null || holders.length === 0)) return true;
+    const portFree = holders === null ? await daemonPortIsFree(port) : holders.length === 0;
+    if (!healthy && portFree) return true;
     await delay3(500);
   }
   return false;
 }
-async function gracefullyStopOwnedDaemon(port) {
-  const pids = await ownedDaemonPids(port);
-  for (const pid of pids) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {
+async function reclaimOwnedDaemonListener(port = getDaemonPort(), dependencies = DEFAULT_RECLAIM_DEPENDENCIES) {
+  const holders = await dependencies.holderPids(port);
+  if (holders === null) {
+    if (await dependencies.portIsFree(port)) {
+      return { ok: true, action: "free", port, clearedPids: [], blockedPids: [] };
     }
+    return {
+      ok: false,
+      action: "blocked",
+      port,
+      clearedPids: [],
+      blockedPids: [],
+      reason: "Could not identify the process holding the daemon port"
+    };
   }
-  if (await waitForDaemonStopped(port)) return true;
-  const survivors = await ownedDaemonPids(port);
-  for (const pid of survivors) {
-    try {
-      process.kill(pid, "SIGKILL");
-    } catch {
+  const uniqueHolders = [...new Set(holders.filter((pid) => pid > 0 && pid !== process.pid))];
+  if (uniqueHolders.length === 0) {
+    if (await dependencies.portIsFree(port)) {
+      return { ok: true, action: "free", port, clearedPids: [], blockedPids: [] };
+    }
+    return {
+      ok: false,
+      action: "blocked",
+      port,
+      clearedPids: [],
+      blockedPids: [],
+      reason: "Daemon port is occupied but its holder could not be verified"
+    };
+  }
+  const ownerId = `daemon:${port}`;
+  const activeLeases = dependencies.leases().filter(
+    (lease) => lease.status === "active" && lease.ownerKind === "daemon" && lease.ownerId === ownerId && uniqueHolders.includes(lease.pid)
+  );
+  const leasesByPid = new Map(activeLeases.map((lease) => [lease.pid, lease]));
+  const blockedPids = uniqueHolders.filter((pid) => !leasesByPid.has(pid));
+  if (blockedPids.length > 0) {
+    return {
+      ok: false,
+      action: "blocked",
+      port,
+      clearedPids: [],
+      blockedPids,
+      reason: "Port holder is not an identity-verified Omnius daemon lease"
+    };
+  }
+  const clearedPids = [];
+  for (const pid of uniqueHolders) {
+    const lease = leasesByPid.get(pid);
+    const stopped = await dependencies.stopLease(lease.leaseId);
+    if (stopped.action !== "killed" && stopped.action !== "dead") {
+      return {
+        ok: false,
+        action: "failed",
+        port,
+        clearedPids,
+        blockedPids: [pid],
+        reason: stopped.reason || "Daemon lease identity could not be verified"
+      };
     }
+    clearedPids.push(pid);
   }
-  return waitForDaemonStopped(port, 10);
+  if (!await dependencies.waitForFree(port)) {
+    return {
+      ok: false,
+      action: "failed",
+      port,
+      clearedPids,
+      blockedPids: [],
+      reason: "Verified daemon stopped but the port did not become free"
+    };
+  }
+  return { ok: true, action: "cleared", port, clearedPids, blockedPids: [] };
 }
 async function restartDaemon(port, expectedVersion) {
   const p2 = port ?? getDaemonPort();
@@ -678417,9 +678469,15 @@ async function restartDaemon(port, expectedVersion) {
       if (started.ok && (await waitForDaemonReady(p2, expectedVersion)).ok) return true;
     }
     await runUserSystemctl(["stop", "omnius-daemon.service"]);
-    if (!await waitForDaemonStopped(p2)) return false;
+    if (!await waitForDaemonStopped(p2)) {
+      const reclaimed = await reclaimOwnedDaemonListener(p2);
+      if (!reclaimed.ok) return false;
+    }
+  }
+  if (await isDaemonRunning(p2)) {
+    const reclaimed = await reclaimOwnedDaemonListener(p2);
+    if (!reclaimed.ok) return false;
   }
-  if (await isDaemonRunning(p2) && !await gracefullyStopOwnedDaemon(p2)) return false;
   const pid = await startDaemon(p2);
   if (!pid) return false;
   return (await waitForDaemonReady(p2, expectedVersion)).ok;
@@ -678496,7 +678554,7 @@ async function startDaemon(port = getDaemonPort()) {
     outFd = openSync4(join128(OMNIUS_DIR, "daemon.log"), "a");
     errFd = openSync4(join128(OMNIUS_DIR, "daemon.err.log"), "a");
     const leaseId = newProcessLeaseId("daemon");
-    const ownerId = `daemon:${getDaemonPort()}`;
+    const ownerId = `daemon:${daemonPort}`;
     const child = spawn28(daemonCommand.command, daemonCommand.args, {
       detached: true,
       stdio: ["ignore", outFd, errFd],
@@ -678670,17 +678728,17 @@ async function ensureDaemonVersion(expectedVersion = getLocalCliVersion(), port
     }
     return finish(true, "unchanged", await getDaemonReportedVersion(port));
   }
-  const stalePid = getDaemonPid();
-  if (stalePid) {
-    try {
-      process.kill(stalePid, "SIGTERM");
-    } catch {
-    }
-    try {
-      unlinkSync22(PID_FILE);
-    } catch {
-    }
+  const reclaimed = await reclaimOwnedDaemonListener(port);
+  if (!reclaimed.ok) {
+    return finish(
+      false,
+      "failed",
+      null,
+      0,
+      process.platform === "linux" && reclaimed.action === "blocked"
+    );
   }
+  getDaemonPid();
   const pid = await startDaemon(port);
   if (!pid) {
     for (let i2 = 0; i2 < 20; i2++) {
@@ -678728,7 +678786,7 @@ async function getDaemonStatus() {
   }
   return { running, pid, port, uptime: uptime2, pidFile: PID_FILE };
 }
-var OMNIUS_DIR, PID_FILE, DEFAULT_PORT2, LOCK_INITIALIZATION_GRACE_MS, DAEMON_VERSION_RECOVERY_ATTEMPTS, DAEMON_GRACEFUL_STOP_ATTEMPTS;
+var OMNIUS_DIR, PID_FILE, DEFAULT_PORT2, LOCK_INITIALIZATION_GRACE_MS, DAEMON_VERSION_RECOVERY_ATTEMPTS, DAEMON_GRACEFUL_STOP_ATTEMPTS, DEFAULT_RECLAIM_DEPENDENCIES;
 var init_daemon = __esm({
   "packages/cli/src/daemon.ts"() {
     init_dist5();
@@ -678738,6 +678796,16 @@ var init_daemon = __esm({
     LOCK_INITIALIZATION_GRACE_MS = 5e3;
     DAEMON_VERSION_RECOVERY_ATTEMPTS = 2;
     DAEMON_GRACEFUL_STOP_ATTEMPTS = 20;
+    DEFAULT_RECLAIM_DEPENDENCIES = {
+      holderPids: (port) => portHolderPids(port),
+      portIsFree: (port) => daemonPortIsFree(port),
+      leases: () => listProcessLeases({ includeInactive: false }),
+      stopLease: (leaseId) => stopProcessLease(leaseId, {
+        reason: "stale daemon listener reclaim",
+        termGraceMs: 1e3
+      }),
+      waitForFree: (port) => waitForDaemonStopped(port)
+    };
   }
 });
 
@@ -678757,6 +678825,7 @@ __export(tray_exports, {
   runTrayForeground: () => runTrayForeground,
   startTray: () => startTray,
   stopTray: () => stopTray,
+  trayRequiresRestart: () => trayRequiresRestart,
   traySupport: () => traySupport,
   trayUpdatePresentation: () => trayUpdatePresentation,
   uninstallTrayAutostart: () => uninstallTrayAutostart,
@@ -679149,7 +679218,7 @@ start "" /b ${argv.map(windowsCmdQuote).join(" ")}\r
   }
   throw new Error(`Autostart is not supported on ${platform8}`);
 }
-function installTrayAutostart(endpoint) {
+function writeTrayAutostart(endpoint) {
   const launch = resolveTrayLaunchCommand();
   if (!launch) throw new Error("Could not resolve the installed Omnius CLI entrypoint");
   const paths = resolveTrayPaths();
@@ -679159,11 +679228,15 @@ function installTrayAutostart(endpoint) {
     buildAutostartContent(process.platform, launch, endpoint, assetPath("online")),
     { encoding: "utf8", mode: process.platform === "win32" ? 448 : 384 }
   );
+  return paths.autostartFile;
+}
+function installTrayAutostart(endpoint) {
+  const autostartFile = writeTrayAutostart(endpoint);
   if (process.platform === "darwin" && typeof process.getuid === "function") {
     spawnSync9("launchctl", ["bootout", `gui/${process.getuid()}/ai.omnius.tray`], { stdio: "ignore" });
-    spawnSync9("launchctl", ["bootstrap", `gui/${process.getuid()}`, paths.autostartFile], { stdio: "ignore" });
+    spawnSync9("launchctl", ["bootstrap", `gui/${process.getuid()}`, autostartFile], { stdio: "ignore" });
   }
-  return paths.autostartFile;
+  return autostartFile;
 }
 function uninstallTrayAutostart() {
   const paths = resolveTrayPaths();
@@ -679295,11 +679368,15 @@ async function getTrayStatus(explicitEndpoint) {
   }
   const state = readProcessState(paths.stateFile);
   const support = traySupport();
+  const requestedEndpoint = resolveTrayEndpoint(explicitEndpoint);
   return {
     running,
     ready: running && Boolean(state?.ready),
     pid: running ? pid : null,
-    endpoint: state?.endpoint || resolveTrayEndpoint(explicitEndpoint),
+    // A stopped indicator's cached state must not override an explicitly
+    // requested endpoint. This previously kept resurrecting an obsolete
+    // custom port (for example 11535) after the daemon had returned to 11435.
+    endpoint: running || !explicitEndpoint ? state?.endpoint || requestedEndpoint : requestedEndpoint,
     registered: existsSync117(paths.autostartFile),
     registrationFile: paths.autostartFile,
     ...state?.health ? { health: state.health } : {},
@@ -679308,16 +679385,26 @@ async function getTrayStatus(explicitEndpoint) {
     ...state?.error ? { error: state.error } : {}
   };
 }
+function trayRequiresRestart(existing, endpoint, liveHealth) {
+  return existing.endpoint !== endpoint || !existing.ready || Boolean(existing.error) || existing.health?.kind !== liveHealth.kind || existing.health?.version !== liveHealth.version;
+}
 async function startTray(explicitEndpoint) {
-  const existing = await getTrayStatus(explicitEndpoint);
-  if (existing.running) return existing;
+  const endpoint = resolveTrayEndpoint(explicitEndpoint);
+  const existing = await getTrayStatus(endpoint);
+  if (existing.running) {
+    const liveHealth = await pollTrayHealth(endpoint);
+    if (!trayRequiresRestart(existing, endpoint, liveHealth)) {
+      return { ...existing, health: liveHealth };
+    }
+    await stopTray();
+  }
   const support = traySupport();
   if (!support.supported) throw new Error(support.reason || "Tray is not supported on this host");
   verifyTrayHelper();
   const launch = resolveTrayLaunchCommand();
   if (!launch) throw new Error("Could not resolve the installed Omnius CLI entrypoint");
-  const endpoint = resolveTrayEndpoint(explicitEndpoint);
   const paths = resolveTrayPaths();
+  if (existing.registered) writeTrayAutostart(endpoint);
   mkdirSync70(paths.stateDir, { recursive: true, mode: 448 });
   mkdirSync70(paths.runtimeDir, { recursive: true, mode: 448 });
   try {
@@ -724408,7 +724495,15 @@ var indicator_command_exports = {};
 __export(indicator_command_exports, {
   runIndicatorCommand: () => runIndicatorCommand
 });
-function formatIndicatorStatus(status) {
+async function waitForOnlineHealth(endpoint, operations, attempts = 5) {
+  let health = await operations.health(endpoint);
+  for (let attempt = 1; health.kind !== "online" && attempt < attempts; attempt++) {
+    await operations.wait(200);
+    health = await operations.health(endpoint);
+  }
+  return health;
+}
+function formatIndicatorStatus(status, daemon) {
   const state = status.running ? status.ready ? "ready" : "starting" : "stopped";
   const pid = status.pid ? ` (PID ${status.pid})` : "";
   const health = status.health?.label ?? "not checked";
@@ -724419,6 +724514,12 @@ function formatIndicatorStatus(status) {
     `Endpoint: ${status.endpoint}.`,
     `Autostart: ${autostart}.`
   ];
+  if (daemon) {
+    const version5 = daemon.observedVersion ?? daemon.expectedVersion;
+    parts.push(
+      `Daemon: ${daemon.action}${version5 ? ` (v${version5})` : ""} on port ${daemon.port}.`
+    );
+  }
   if (status.error) parts.push(`Error: ${status.error}`);
   return parts.join(" ");
 }
@@ -724431,9 +724532,42 @@ async function runIndicatorCommand(rawAction, operations = DEFAULT_OPERATIONS) {
     };
   }
   try {
-    const status = action === "status" ? await operations.status() : await operations.start();
-    const level = status.error ? "error" : status.running && status.ready ? "info" : status.running ? "warning" : action === "start" ? "error" : "warning";
-    return { level, message: formatIndicatorStatus(status), status };
+    if (action === "status") {
+      const cached2 = await operations.status();
+      const health2 = await operations.health(cached2.endpoint);
+      const status2 = { ...cached2, health: health2 };
+      const level2 = status2.error ? "error" : status2.running && status2.ready && health2.kind === "online" ? "info" : "warning";
+      return { level: level2, message: formatIndicatorStatus(status2), status: status2 };
+    }
+    const daemon = await operations.ensureDaemon();
+    if (!daemon.ok) {
+      const observed = daemon.observedVersion ? `; observed v${daemon.observedVersion}` : "";
+      const migration = daemon.requiresPrivilegedMigration ? " Privileged service migration is required; run /daemon takeover." : "";
+      return {
+        level: "error",
+        message: `Indicator not started: daemon reconciliation failed on port ${daemon.port}${observed}.${migration}`,
+        daemon
+      };
+    }
+    const endpoint = `http://127.0.0.1:${daemon.port}`;
+    const daemonHealth = await waitForOnlineHealth(endpoint, operations);
+    if (daemonHealth.kind !== "online") {
+      return {
+        level: "error",
+        message: `Indicator not started: daemon did not become online at ${endpoint}. ` + daemonHealth.tooltip,
+        daemon
+      };
+    }
+    const started = await operations.start(endpoint);
+    const health = await waitForOnlineHealth(endpoint, operations);
+    const status = { ...started, endpoint, health };
+    const level = status.error ? "error" : status.running && status.ready && health.kind === "online" ? "info" : "error";
+    return {
+      level,
+      message: formatIndicatorStatus(status, daemon),
+      status,
+      daemon
+    };
   } catch (error) {
     return {
       level: "error",
@@ -724445,9 +724579,13 @@ var DEFAULT_OPERATIONS;
 var init_indicator_command = __esm({
   "packages/cli/src/tui/indicator-command.ts"() {
     init_tray();
+    init_daemon();
     DEFAULT_OPERATIONS = {
-      start: () => startTray(),
-      status: () => getTrayStatus()
+      ensureDaemon: () => ensureDaemonVersion(),
+      start: (endpoint) => startTray(endpoint),
+      status: () => getTrayStatus(),
+      health: (endpoint) => pollTrayHealth(endpoint),
+      wait: (ms) => new Promise((resolve87) => setTimeout(resolve87, ms))
     };
   }
 });

package/docs/guides/system-tray.md

@@ -25,6 +25,12 @@ From an active Omnius TUI, use the local slash command instead:
 start/stop/restart lifecycle remain available through the top-level
 `omnius tray` command.
 
+`/indicator` first reconciles the current Omnius daemon on its configured
+loopback port (11435 by default), waits for verified online health, repairs a
+stale tray endpoint/autostart registration, and only then starts the native
+indicator. Untracked processes occupying the port are reported as blockers and
+are never terminated automatically.
+
 The indicator polls the daemon's loopback-only `GET /health` route. It does not
 load a model or contact the configured inference backend. If the daemon uses a
 non-default port, Omnius discovers `OMNIUS_HOST`/`OMNIUS_PORT` from the current

package/npm-shrinkwrap.json

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

package/package.json

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