omnius 1.0.604 → 1.0.605

package/dist/index.js

@@ -363,6 +363,7 @@ __export(update_service_exports, {
   UpdateInProgressError: () => UpdateInProgressError,
   assertExactUpdateTarget: () => assertExactUpdateTarget,
   inspectGlobalOmniusInstall: () => inspectGlobalOmniusInstall,
+  readReconciledUpdateState: () => readReconciledUpdateState,
   readUpdateLogTail: () => readUpdateLogTail,
   readUpdateState: () => readUpdateState,
   releaseUpdateLock: () => releaseUpdateLock,
@@ -373,6 +374,7 @@ __export(update_service_exports, {
   updateStateFileIsPrivate: () => updateStateFileIsPrivate,
   updateStateIsFreshRunning: () => updateStateIsFreshRunning,
   updateStatusSnapshot: () => updateStatusSnapshot,
+  waitForUpdateTransaction: () => waitForUpdateTransaction,
   writeUpdateState: () => writeUpdateState
 });
 import { spawn, spawnSync } from "node:child_process";
@@ -613,6 +615,68 @@ 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;
 }
+function installGlobalPackageStreaming(input) {
+  return new Promise((resolve87) => {
+    const stderrTail = [];
+    let settled = false;
+    let timedOut = false;
+    const finish = (exitCode, error) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      resolve87({ exitCode, ...error ? { error } : {} });
+    };
+    const child = spawn(
+      input.npmPath,
+      [
+        "install",
+        "-g",
+        `omnius@${input.targetVersion}`,
+        "--prefer-online",
+        "--no-audit",
+        "--no-fund",
+        "--no-progress"
+      ],
+      {
+        env: input.env,
+        stdio: ["ignore", "pipe", "pipe"],
+        windowsHide: true
+      }
+    );
+    child.stdout?.on("data", (chunk) => {
+      process.stdout.write(chunk);
+    });
+    child.stderr?.on("data", (chunk) => {
+      const text2 = String(chunk);
+      process.stderr.write(text2);
+      stderrTail.push(text2);
+      while (stderrTail.join("").length > 8e3 && stderrTail.length > 1) stderrTail.shift();
+    });
+    child.once("error", (error) => finish(-1, error.message));
+    child.once("close", (code8, signal) => {
+      const exitCode = code8 ?? -1;
+      const evidence = stderrTail.join("").trim();
+      finish(
+        exitCode,
+        exitCode === 0 ? void 0 : timedOut ? "npm install timed out after 5 minutes" : evidence || `npm install exited with ${signal ? `signal ${signal}` : `code ${exitCode}`}`
+      );
+    });
+    const timer = setTimeout(() => {
+      timedOut = true;
+      try {
+        child.kill("SIGTERM");
+      } catch {
+      }
+      const forceTimer = setTimeout(() => {
+        try {
+          child.kill("SIGKILL");
+        } catch {
+        }
+      }, 2500);
+      forceTimer.unref?.();
+    }, 5 * 6e4);
+  });
+}
 async function runVerifiedUpdateTransaction(initial, dependencies, paths = resolveUpdatePaths()) {
   let state = initial;
   const target = assertExactUpdateTarget(initial.target_version);
@@ -632,27 +696,7 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
       npm_path: npmPath,
       ...prefixProbe.status === 0 && prefixProbe.stdout.trim() ? { npm_prefix: prefixProbe.stdout.trim() } : {}
     }, paths);
-    const installer = dependencies.install ?? (async ({ npmPath: command, targetVersion, env: childEnv }) => {
-      const result = runSync(
-        command,
-        [
-          "install",
-          "-g",
-          `omnius@${targetVersion}`,
-          "--prefer-online",
-          "--no-audit",
-          "--no-fund",
-          "--no-progress"
-        ],
-        { env: childEnv, timeout: 5 * 6e4 }
-      );
-      if (result.stdout) process.stdout.write(result.stdout);
-      if (result.stderr) process.stderr.write(result.stderr);
-      return {
-        exitCode: result.status ?? -1,
-        ...result.error || result.status !== 0 ? { error: result.error?.message || result.stderr.trim() || `npm install exited with code ${result.status ?? -1}` } : {}
-      };
-    });
+    const installer = dependencies.install ?? installGlobalPackageStreaming;
     const installResult = await installer({ npmPath, targetVersion: target, env: env2 });
     state = transition(state, { installer_exit_code: installResult.exitCode }, paths);
     if (installResult.exitCode !== 0) {
@@ -721,6 +765,13 @@ function startDetachedGlobalUpdate(input, paths = resolveUpdatePaths()) {
   const operationId = randomUUID();
   const lockFd = acquireUpdateLock(operationId, paths);
   closeSync(lockFd);
+  const workerPath = fileURLToPath(new URL("./update-worker.js", import.meta.url));
+  if (!existsSync2(workerPath)) {
+    releaseUpdateLock(paths, operationId);
+    throw new Error(
+      `The coordinated update worker is missing at ${workerPath}. Reinstall Omnius from a package that ships dist/update-worker.js.`
+    );
+  }
   const now2 = (/* @__PURE__ */ new Date()).toISOString();
   let state = {
     schema_version: 1,
@@ -737,10 +788,15 @@ function startDetachedGlobalUpdate(input, paths = resolveUpdatePaths()) {
     tray_restarted: false
   };
   writeUpdateState(state, paths);
-  const workerPath = fileURLToPath(new URL("./update-worker.js", import.meta.url));
   rotateUpdateLog(paths);
   const logFd = openSync(paths.logFile, "a", 384);
   try {
+    writeSync(
+      logFd,
+      `
+[omnius update ${operationId}] ${input.fromVersion} -> ${targetVersion} ${now2}
+`
+    );
     const child = spawn(
       process.execPath,
       [
@@ -805,6 +861,32 @@ function updateStatusSnapshot(paths = resolveUpdatePaths()) {
     log_tail: readUpdateLogTail(paths)
   };
 }
+function readReconciledUpdateState(paths = resolveUpdatePaths()) {
+  const snapshot = updateStatusSnapshot(paths).state;
+  return snapshot.status === "idle" ? null : snapshot;
+}
+async function waitForUpdateTransaction(operationId, options2 = {}, paths = resolveUpdatePaths()) {
+  const pollIntervalMs = Math.max(25, options2.pollIntervalMs ?? 300);
+  const timeoutMs = Math.max(pollIntervalMs, options2.timeoutMs ?? 10 * 6e4);
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() <= deadline) {
+    const snapshot = updateStatusSnapshot(paths);
+    if (snapshot.state.status !== "idle") {
+      if (snapshot.state.operation_id !== operationId) {
+        throw new Error(
+          `Update operation changed from ${operationId} to ${snapshot.state.operation_id}`
+        );
+      }
+      options2.onProgress?.({
+        state: snapshot.state,
+        log_tail: snapshot.log_tail
+      });
+      if (snapshot.state.status !== "running") return snapshot.state;
+    }
+    await new Promise((resolve87) => setTimeout(resolve87, pollIntervalMs));
+  }
+  throw new Error(`Update operation ${operationId} did not finish within ${timeoutMs}ms`);
+}
 function updateStateIsFreshRunning(state) {
   if (!state || state.status !== "running") return false;
   if (isPidAlive(state.pid)) return true;
@@ -679731,7 +679813,7 @@ async function runTrayForeground(explicitEndpoint) {
     let updateView = trayUpdatePresentation(
       health.version,
       availableUpdate?.latestVersion,
-      readUpdateState()
+      readReconciledUpdateState()
     );
     const menuState = menuForHealth(health, endpoint, registered, updateView);
     const SysTray = await loadSysTray();
@@ -679773,7 +679855,7 @@ async function runTrayForeground(explicitEndpoint) {
       updateView = trayUpdatePresentation(
         health.version,
         availableUpdate?.latestVersion,
-        readUpdateState()
+        readReconciledUpdateState()
       );
       menuState.updateItem.title = updateView.title;
       menuState.updateItem.tooltip = updateView.tooltip;
@@ -679842,7 +679924,7 @@ async function runTrayForeground(explicitEndpoint) {
                 endpoint,
                 trayWasRunning: true
               });
-              updateView = trayUpdatePresentation(currentVersion, targetVersion, readUpdateState());
+              updateView = trayUpdatePresentation(currentVersion, targetVersion, readReconciledUpdateState());
               if (updateView.enabled) {
                 updateView = {
                   title: `Updating to v${targetVersion} — starting`,
@@ -679879,7 +679961,7 @@ async function runTrayForeground(explicitEndpoint) {
             updateView = trayUpdatePresentation(
               currentVersion,
               availableUpdate?.latestVersion,
-              readUpdateState()
+              readReconciledUpdateState()
             );
             menuState.updateItem.title = updateView.title;
             menuState.updateItem.tooltip = updateView.tooltip;
@@ -747939,8 +748021,12 @@ async function handleUpdate(subcommand, ctx3) {
       renderInfo(`Omnius v${currentVersion} is already up to date.`);
       return;
     }
+    const updateOverlay = startInstallOverlay(info.latestVersion);
+    updateOverlay.setPhase("Preparing");
+    updateOverlay.setProgress(0, 6);
+    updateOverlay.setStatus("starting coordinated global update");
     try {
-      const [{ startDetachedGlobalUpdate: startDetachedGlobalUpdate2 }, { getTrayStatus: getTrayStatus2 }] = await Promise.all([
+      const [{ startDetachedGlobalUpdate: startDetachedGlobalUpdate2, waitForUpdateTransaction: waitForUpdateTransaction2 }, { getTrayStatus: getTrayStatus2 }] = await Promise.all([
         Promise.resolve().then(() => (init_update_service(), update_service_exports)),
         Promise.resolve().then(() => (init_tray(), tray_exports))
       ]);
@@ -747951,11 +748037,52 @@ async function handleUpdate(subcommand, ctx3) {
         endpoint: trayStatus.endpoint,
         trayWasRunning: trayStatus.running
       });
+      const phasePresentation = {
+        queued: { label: "Preparing", progress: 0, status: "update worker queued" },
+        installing: { label: "Package", progress: 1, status: `installing omnius@${info.latestVersion}` },
+        package_verified: { label: "Verification", progress: 2, status: "global package and executable verified" },
+        daemon_restarting: { label: "Daemon", progress: 3, status: "restarting shared daemon" },
+        runtime_verified: { label: "Runtime", progress: 4, status: "daemon version and package hash verified" },
+        tray_restarting: { label: "Indicator", progress: 5, status: "restarting system indicator" },
+        completed: { label: "Complete", progress: 6, status: "global runtime update verified" },
+        failed: { label: "Failed", progress: 6, status: "update verification failed" }
+      };
+      const marker = `[omnius update ${started.state.operation_id}]`;
+      const terminal = await waitForUpdateTransaction2(
+        started.state.operation_id,
+        {
+          pollIntervalMs: 250,
+          timeoutMs: 10 * 6e4,
+          onProgress(snapshot) {
+            const view = phasePresentation[snapshot.state.phase];
+            updateOverlay.setPhase(view.label);
+            updateOverlay.setProgress(view.progress, 6);
+            const operationLog = snapshot.log_tail.includes(marker) ? snapshot.log_tail.slice(snapshot.log_tail.lastIndexOf(marker) + marker.length) : snapshot.log_tail;
+            const liveLine = operationLog.replace(/\x1B\][^\x07]*(?:\x07|\x1B\\)/g, "").replace(/\x1B\[[0-?]*[ -/]*[@-~]/g, "").split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !/^npm notice/i.test(line)).at(-1);
+            updateOverlay.setStatus((liveLine || view.status).slice(0, 100));
+          }
+        }
+      );
+      if (terminal.status === "failed") {
+        updateOverlay.dismiss();
+        renderError(`Update to v${info.latestVersion} failed: ${terminal.error || "unknown error"}`);
+        if (terminal.remediation) renderWarning(terminal.remediation);
+        return;
+      }
+      updateOverlay.stop("Package, daemon, and indicator verified");
+      await new Promise((resolve87) => setTimeout(resolve87, 1e3));
+      updateOverlay.dismiss();
       renderInfo(
-        `Global update to v${info.latestVersion} started (${started.state.operation_id.slice(0, 8)}). Track exact install/runtime verification at ${started.state.log_path}.`
+        `Updated Omnius v${currentVersion} → v${terminal.installed_version ?? info.latestVersion}; daemon v${terminal.daemon_version ?? info.latestVersion}${terminal.tray_was_running ? ", indicator restarted" : ""}.`
       );
+      ctx3.contextSave?.();
+      ctx3.savePendingTaskState?.();
+      if (ctx3.hasActiveTask?.()) ctx3.abortActiveTask?.();
+      ctx3.killEphemeral?.({ preserveInfrastructure: true });
+      process.exit(120);
     } catch (error) {
-      renderError(`Update failed to start: ${error instanceof Error ? error.message : String(error)}`);
+      updateOverlay.dismiss();
+      renderError(`Update failed: ${error instanceof Error ? error.message : String(error)}`);
     }
     return;
   }