omnius 1.0.898 → 1.0.899

package/dist/index.js

@@ -1,4 +1,4 @@
 [diffend] Oversized file quarantined before diffing.
 name: package/dist/index.js
-size: 38893092 bytes
-sha256: 29c5ce6e105bcb95312f49412898037a7be5853407e5c1841130598073a9b555
+size: 39003716 bytes
+sha256: b6edef747f657c5b2a3d457343f93a79c376d250cf0aaffa2e59e7666d232f24

package/dist/library.js

@@ -374916,7 +374916,7 @@ function classifyFailureKind(text14, args) {
   if (/\[PROPOSAL_MODE_REQUIRED\]|proposal\/copy-on-write mode|proposal mode only|copy-on-write patch proposal/i.test(text14)) {
     return "proposal_mode_required";
   }
-  if (/\[COMPLETION BLOCKED|Resolution gate HELD|held by todo verification|\[MISSION COMPLETION CONTRACT|Backward-pass critique requested changes|completion gate|task_complete held/i.test(text14)) {
+  if (/\[COMPLETION BLOCKED|\bCompletion blocked:|Resolution gate HELD|held by todo verification|\[MISSION COMPLETION CONTRACT|Backward-pass critique requested changes|completion gate|task_complete held/i.test(text14)) {
     return "completion_hold";
   }
   if (/\[MUTATION_SCOPE_CONFLICT\]|mutation scope conflict|outside this worker's owned|coordinator-owned|already owns overlapping scope|artifact lease/i.test(text14)) {

package/dist/omnius-tray-install.cjs

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+"use strict";
+
+// Shared by the package installer and explicit daemon service installation.
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+const cp = require("node:child_process");
+const { randomUUID } = require("node:crypto");
+
+function safe(value) {
+  if (typeof value !== "string" || !value || /[\r\n\0]/.test(value)) throw new Error("Invalid tray installation path");
+  return value;
+}
+const unitQuote = value => '"' + safe(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%") + '"';
+const desktopQuote = value => '"' + safe(value).replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/%/g, "%%").replace(/[$`]/g, "\\$&") + '"';
+
+function trayCompanionContents(options) {
+  const endpoint = `http://127.0.0.1:${options.port || 11435}`;
+  const argv = [options.nodePath, options.entrypoint, "tray", "run", "--endpoint", endpoint];
+  const unit = [
+    "[Unit]", "Description=Omnius desktop indicator", "PartOf=graphical-session.target",
+    "After=graphical-session.target", "StartLimitIntervalSec=60", "StartLimitBurst=5", "",
+    "[Service]", "Type=simple", `WorkingDirectory=${safe(options.homeDir).replace(/%/g, "%%")}`,
+    `Environment=${unitQuote(`OMNIUS_HOME=${options.dataDir || path.join(options.homeDir, ".omnius")}`)}`,
+    `ExecStart=${argv.map(value => unitQuote(value).replace(/\$/g, () => "$$")).join(" ")}`, "Restart=on-failure", "RestartSec=5",
+    "TimeoutStopSec=10", "", "[Install]", "WantedBy=graphical-session.target", "",
+  ].join("\n");
+  const launch = options.userSystemd
+    ? ["/usr/bin/systemctl", "--user", "start", "omnius-tray.service"] : argv;
+  const desktop = [
+    "[Desktop Entry]", "Type=Application", "Version=1.0", "Name=Omnius",
+    "Comment=Omnius daemon and Telegram workspace controls", `Exec=${launch.map(desktopQuote).join(" ")}`,
+    "Terminal=false", "X-GNOME-Autostart-enabled=true", "StartupNotify=false", "",
+  ].join("\n");
+  return { unit, desktop };
+}
+
+function installTrayCompanion(options = {}) {
+  if ((options.platform || process.platform) !== "linux") return { installed: false, started: false, reason: "platform" };
+  const run = options.run || ((command, args) => cp.execFileSync(command, args, { encoding: "utf8", timeout: 10000, stdio: ["ignore", "pipe", "pipe"] }));
+  const homeDir = path.resolve(safe(options.homeDir || os.homedir()));
+  const userName = options.userName || process.env.SUDO_USER || os.userInfo().username;
+  const uid = Number(options.uid ?? run("id", ["-u", userName]).trim());
+  const gid = Number(options.gid ?? run("id", ["-g", userName]).trim());
+  if (!Number.isSafeInteger(uid) || uid < 0 || !Number.isSafeInteger(gid) || gid < 0) throw new Error("Invalid tray owner");
+  const opts = { ...options, nodePath: safe(options.nodePath || process.execPath),
+    entrypoint: safe(options.entrypoint || path.join(__dirname, "..", "dist", "launcher.cjs")), homeDir };
+  if (!Number.isInteger(opts.port ?? 11435) || (opts.port ?? 11435) < 1 || (opts.port ?? 11435) > 65535) throw new Error("Invalid tray port");
+  // A root package installation must never write through desktop-owner paths
+  // with root privileges. Let the owner create their own companion artifacts.
+  if (process.getuid?.() === 0 && uid !== 0 && !options.run) {
+    const args = ["-u", userName, "--", "env", `HOME=${homeDir}`, `USER=${userName}`, `LOGNAME=${userName}`,
+      `XDG_RUNTIME_DIR=/run/user/${uid}`, `DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/${uid}/bus`,
+      opts.nodePath, __filename, "--node", opts.nodePath, "--entrypoint", opts.entrypoint,
+      "--home", homeDir, "--user", userName, "--port", String(opts.port || 11435),
+      ...(opts.dataDir ? ["--data-dir", opts.dataDir] : []), ...(options.start === false ? ["--no-start"] : [])];
+    return JSON.parse(run("runuser", args));
+  }
+  const asUser = args => {
+    const currentUid = typeof process.getuid === "function" ? process.getuid() : uid;
+    if (currentUid === uid) return run("systemctl", ["--user", ...args]);
+    if (currentUid !== 0) throw new Error("Tray installation must run as its desktop owner or root");
+    return run("runuser", ["-u", userName, "--", "env", `XDG_RUNTIME_DIR=/run/user/${uid}`,
+      `DBUS_SESSION_BUS_ADDRESS=unix:path=/run/user/${uid}/bus`, "systemctl", "--user", ...args]);
+  };
+  let environment = "", userSystemd = false;
+  try { environment = asUser(["show-environment"]); userSystemd = true; } catch { /* XDG autostart also supports non-systemd desktops. */ }
+  const { unit, desktop } = trayCompanionContents({ ...opts, userSystemd });
+  const unitFile = path.join(homeDir, ".config", "systemd", "user", "omnius-tray.service");
+  const desktopFile = path.join(homeDir, ".config", "autostart", "omnius-tray.desktop");
+  for (const [file, content] of [[unitFile, unit], [desktopFile, desktop]]) {
+    const directory = path.dirname(file), missing = [];
+    for (let dir = directory; !fs.existsSync(dir); dir = path.dirname(dir)) missing.push(dir);
+    fs.mkdirSync(directory, { recursive: true, mode: 0o700 });
+    for (const dir of missing) if (process.getuid?.() === 0) fs.chownSync(dir, uid, gid);
+    const temporary = `${file}.${randomUUID()}.tmp`;
+    try {
+      fs.writeFileSync(temporary, content, { mode: 0o600, flag: "wx" });
+      if (process.getuid?.() === 0) fs.chownSync(temporary, uid, gid);
+      fs.renameSync(temporary, file);
+    } finally { try { fs.unlinkSync(temporary); } catch {} }
+  }
+  let started = false;
+  if (userSystemd) {
+    asUser(["daemon-reload"]);
+    asUser(["enable", "omnius-tray.service"]);
+    const graphical = /^(?:DISPLAY|WAYLAND_DISPLAY)=.+$/m.test(environment);
+    if (graphical && options.start !== false) {
+      // An upgrade may have replaced the running helper's executable/assets.
+      // Reattach the indicator to the completed installation immediately.
+      asUser(["restart", "omnius-tray.service"]);
+      started = true;
+    }
+  }
+  return { installed: true, started, unitFile, desktopFile, userSystemd };
+}
+
+module.exports = { trayCompanionContents, installTrayCompanion };
+if (require.main === module) {
+  const args = process.argv.slice(2), values = {};
+  const keys = { "--node": "nodePath", "--entrypoint": "entrypoint", "--home": "homeDir", "--user": "userName", "--data-dir": "dataDir", "--port": "port" };
+  try {
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === "--no-start") { values.start = false; continue; }
+      const key = keys[args[i]];
+      if (!key || !args[i + 1]) throw new Error("Invalid tray installer argument");
+      values[key] = key === "port" ? Number(args[++i]) : args[++i];
+    }
+    process.stdout.write(JSON.stringify(installTrayCompanion(values)) + "\n");
+  } catch (error) { process.stderr.write(`Omnius tray installation failed: ${error.message}\n`); process.exitCode = 1; }
+}

package/dist/postinstall-daemon.cjs

@@ -519,6 +519,10 @@ function effectiveUser() {
   if (!IS_WIN && process.getuid && process.getuid() === 0) {
     var sudoUser = process.env.SUDO_USER;
     if (sudoUser) return sudoUser;
+    if (IS_LINUX) {
+      var unitUser = runCapture("systemctl show " + SERVICE_LABEL + ".service --property=User --value").trim();
+      if (/^[a-zA-Z_][a-zA-Z0-9_.-]*\$?$/.test(unitUser) && unitUser !== "root") return unitUser;
+    }
     return null; // Running as bare root — skip per-user service install
   }
   return process.env.USER || process.env.LOGNAME || os.userInfo().username;
@@ -683,12 +687,43 @@ function cleanNexus() {
 
 // ─── Linux: systemd user unit ───────────────────────────────────────────────
 
+function hasSystemDaemonUnit() {
+  if (!IS_LINUX) return false;
+  return runCapture("systemctl show " + SERVICE_LABEL + ".service --property=LoadState --value").trim() === "loaded";
+}
+
+function installDesktopCompanion(nodeBin, omniusScript, user) {
+  if (!user) return;
+  var helper = path.join(__dirname, "omnius-tray-install.cjs");
+  if (!fs.existsSync(helper)) {
+    warn("Desktop tray companion installer is missing from this package.");
+    return;
+  }
+  try {
+    var userHome = HOME;
+    if (IS_LINUX) {
+      var entry = cp.execFileSync("getent", ["passwd", user], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 5000 }).trim().split(":");
+      if (entry[0] === user && entry[5]) userHome = entry[5];
+    }
+    cp.execFileSync(nodeBin, [helper, "--node", nodeBin, "--entrypoint", omniusScript,
+      "--home", userHome, "--user", user, "--data-dir", path.join(userHome, ".omnius"), "--port", String(PORT)],
+      { stdio: "pipe", timeout: 20000 });
+    log("Updated the daemon's desktop tray companion (headless hosts need no tray).");
+  } catch (e) {
+    warn("Desktop tray companion setup failed: " + (e && e.message));
+  }
+}
+
 function installSystemd(nodeBin, omniusScript, user) {
   if (!IS_LINUX) return false;
   if (!hasCmd("systemctl")) {
     warn("systemctl not found — skipping systemd install.");
     return false;
   }
+  if (hasSystemDaemonUnit()) {
+    log("Native system daemon unit is installed; preserving its launcher and sole service ownership.");
+    return true;
+  }
 
   var userHome = user === process.env.USER ? HOME : path.join("/home", user);
   try {
@@ -740,6 +775,9 @@ function installSystemd(nodeBin, omniusScript, user) {
     "Environment=OMNIUS_DAEMON=1",
     "Environment=OMNIUS_PORT=" + PORT,
     "Environment=NODE_ENV=production",
+    "Environment=HOME=" + userHome,
+    "Environment=OMNIUS_HOME=" + path.join(userHome, ".omnius"),
+    "WorkingDirectory=" + userHome,
     // Keep this user-relative so a unit written during a root/global install
     // still loads the owning user's overrides after the existing unit is
     // rewritten on update.
@@ -751,6 +789,9 @@ function installSystemd(nodeBin, omniusScript, user) {
     // Pair with StartLimitIntervalSec to prevent thrash loops.
     "Restart=always",
     "RestartSec=3",
+    "KillSignal=SIGTERM",
+    "KillMode=process",
+    "TimeoutStopSec=120",
     "StandardOutput=append:" + path.join(logDir, "daemon.log"),
     "StandardError=append:" + path.join(logDir, "daemon.err.log"),
     "",
@@ -1094,9 +1135,11 @@ function main() {
   if (!ensureCoreCommandAvailable()) return fatalExit(1);
 
   // The coordinated worker already owns service handoff and verifies the
-  // replacement package/runtime. Ancillary model/native/companion setup must
-  // not hold this package transaction open or mutate unrelated runtime state.
+  // replacement package/runtime. Skip model/native provisioning here; keep
+  // the shared desktop companion registered to the newly installed package.
   if (process.env.OMNIUS_UPDATE_COORDINATED === "1") {
+    var companionEntrypoint = resolveOmniusBinary();
+    if (companionEntrypoint) installDesktopCompanion(resolveNodeBinary(), companionEntrypoint, effectiveUser());
     log("Coordinated update owns daemon restart and exact-version verification.");
     return safeExit(0);
   }
@@ -1123,6 +1166,8 @@ function main() {
 
   if (process.env.OMNIUS_SKIP_DAEMON_INSTALL === "1") {
     log("OMNIUS_SKIP_DAEMON_INSTALL=1 — skipping daemon service install.");
+    var skippedDaemonEntrypoint = resolveOmniusBinary();
+    if (skippedDaemonEntrypoint) installDesktopCompanion(resolveNodeBinary(), skippedDaemonEntrypoint, effectiveUser());
     return safeExit(0);
   }
 
@@ -1133,6 +1178,10 @@ function main() {
   // the new service-managed daemon fails to bind port 11435 and the user
   // ends up running stale in-memory code from the previous version.
   progress(6, INSTALL_STEPS, "Clearing daemon port");
+  if (hasSystemDaemonUnit()) {
+    log("Native system service owns daemon restart; skipping standalone process signals.");
+    return runMainAfterKill();
+  }
   stopAttestedDaemonPortHolder(PORT, function (killedCount) {
     if (killedCount > 0) {
       log("Killed " + killedCount + " stale daemon process(es) holding port " + PORT + ".");
@@ -1172,8 +1221,8 @@ function runMainAfterKill() {
     if (!user) {
       warn("Running as bare root with no SUDO_USER — skipping per-user service install.");
       warn("Re-run as your user, or run: OMNIUS_SKIP_DAEMON_INSTALL=0 npm i -g omnius");
-      // Still spawn detached so the port is live right now.
-      spawnDetached(nodeBin, omniusScript);
+      // An unidentified desktop/service owner must never become a competing
+      // root daemon merely because npm itself is running as administrator.
       return safeExit(0);
     }
 
@@ -1192,6 +1241,7 @@ function runMainAfterKill() {
       // Fallback: spawn a detached child so at least the port is live NOW.
       spawnDetached(nodeBin, omniusScript);
     }
+    installDesktopCompanion(nodeBin, omniusScript, user);
 
     // Wait up to 15s for /health to come up, but don't fail npm install.
     progress(8, INSTALL_STEPS, "Verifying daemon health");