omnius 1.0.867 → 1.0.868

package/dist/update-worker.js

@@ -2589,12 +2589,20 @@ var init_identity_kernel = __esm({
   }
 });
 
+// packages/execution/dist/tools/media-progress.js
+var init_media_progress = __esm({
+  "packages/execution/dist/tools/media-progress.js"() {
+    "use strict";
+  }
+});
+
 // packages/execution/dist/tools/audio-generate.js
 var DIFFUSERS_AUDIO_RUNNER, AUDIOCRAFT_RUNNER, TRANSFORMERS_AUDIO_RUNNER, TANGOFLUX_RUNNER;
 var init_audio_generate = __esm({
   "packages/execution/dist/tools/audio-generate.js"() {
     "use strict";
     init_process_async();
+    init_media_progress();
     init_media_store_lease();
     init_model_broker();
     init_venv_paths();
@@ -296871,6 +296879,9 @@ init_process_lifecycle();
 init_identity_kernel();
 
 // packages/execution/dist/tools/image-generate.js
+init_process_async();
+import { AsyncLocalStorage as AsyncLocalStorage4 } from "node:async_hooks";
+init_media_progress();
 init_media_store_lease();
 init_model_broker();
 init_venv_paths();
@@ -297691,6 +297702,7 @@ def main():
 if __name__ == "__main__":
     main()
 `;
+var imageInvocationSignal = new AsyncLocalStorage4();
 
 // packages/execution/dist/index.js
 init_audio_generate();
@@ -297717,6 +297729,7 @@ var execFileAsync2 = promisify3(execFile3);
 
 // packages/execution/dist/tools/video-generate.js
 init_process_async();
+init_media_progress();
 init_media_store_lease();
 init_model_broker();
 init_venv_paths();
@@ -300151,6 +300164,7 @@ import {
   chmodSync,
   closeSync as closeSync3,
   existsSync as existsSync6,
+  lstatSync,
   mkdirSync as mkdirSync5,
   openSync as openSync3,
   readFileSync as readFileSync6,
@@ -300217,6 +300231,41 @@ function compareOmniusVersions(left, right) {
 }
 
 // packages/cli/src/update-service.ts
+var UpdateCancelledError = class extends Error {
+  constructor(message = "Update cancelled. Package changes already made are retained; no rollback is claimed.") {
+    super(message);
+    this.name = "UpdateCancelledError";
+  }
+};
+function cancellationPath(operationId, paths) {
+  if (!/^[a-zA-Z0-9_-]{1,128}$/.test(operationId)) throw new Error("Invalid update operation identity");
+  return join15(paths.stateDir, `cancel-${operationId}.json`);
+}
+function watchUpdateCancellation(operationId, paths = resolveUpdatePaths()) {
+  const controller = new AbortController();
+  const path3 = cancellationPath(operationId, paths);
+  const check = () => {
+    if (controller.signal.aborted) return;
+    try {
+      const metadata = lstatSync(path3);
+      if (!metadata.isFile() || metadata.isSymbolicLink() || metadata.size > 1024) return;
+      const request = JSON.parse(readFileSync6(path3, "utf8"));
+      const state = readUpdateState(paths);
+      if (state?.operation_id === operationId && state.status === "running" && state.cancel_token_hash && request.operation_id === operationId && request.token_hash === state.cancel_token_hash) controller.abort(new UpdateCancelledError());
+    } catch {
+    }
+  };
+  check();
+  const timer = setInterval(check, 100);
+  timer.unref?.();
+  return { signal: controller.signal, close() {
+    clearInterval(timer);
+    try {
+      unlinkSync3(path3);
+    } catch {
+    }
+  } };
+}
 function resolveUpdatePaths(env = process.env, platform2 = process.platform, home = homedir15()) {
   const stateBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join15(home, "AppData", "Local") : platform2 === "darwin" ? join15(home, "Library", "Application Support") : env["XDG_STATE_HOME"] || join15(home, ".local", "state");
   const cacheBase = platform2 === "win32" ? env["LOCALAPPDATA"] || join15(home, "AppData", "Local") : platform2 === "darwin" ? join15(home, "Library", "Caches") : env["XDG_CACHE_HOME"] || join15(home, ".cache");
@@ -300323,13 +300372,15 @@ function commandVersion(value) {
   const match2 = value.match(/(?:^|\s)v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)(?:\s|$)/);
   return match2?.[1] ?? null;
 }
-async function runCommand(command, args, options = {}) {
+async function runUpdateCommand(command, args, options = {}) {
   if (options.signal?.aborted) {
     return { status: null, stdout: "", stderr: "command cancelled", signal: null, error: new Error("command cancelled") };
   }
   return await new Promise((resolve10) => {
     const child = spawn2(command, args, {
       env: options.env ?? process.env,
+      cwd: options.cwd,
+      shell: options.shell,
       stdio: options.inherit ? ["ignore", "inherit", "inherit"] : ["ignore", "pipe", "pipe"],
       windowsHide: true,
       detached: process.platform !== "win32"
@@ -300341,12 +300392,19 @@ async function runCommand(command, args, options = {}) {
     let stopping = false;
     let timer;
     let forceTimer;
-    let settlementTimer;
     const capture = (current, chunk) => `${current}${chunk.toString()}`.slice(-256 * 1024);
     const signalChild = (signal) => {
       try {
         if (child.pid && process.platform !== "win32") process.kill(-child.pid, signal);
-        else child.kill(signal);
+        else if (child.pid && process.platform === "win32") {
+          const killer = spawn2("taskkill", ["/pid", String(child.pid), "/t", "/f"], { stdio: "ignore", windowsHide: true });
+          killer.once("error", () => {
+            try {
+              child.kill(signal);
+            } catch {
+            }
+          });
+        } else child.kill(signal);
       } catch {
       }
     };
@@ -300357,15 +300415,12 @@ async function runCommand(command, args, options = {}) {
       signalChild("SIGTERM");
       forceTimer = setTimeout(() => signalChild("SIGKILL"), 1e3);
       forceTimer.unref?.();
-      settlementTimer = setTimeout(() => finish({ status: null, stdout, stderr, signal: null, error }), 2e3);
-      settlementTimer.unref?.();
     };
     const finish = (result) => {
       if (settled) return;
       settled = true;
       clearTimeout(timer);
       if (forceTimer) clearTimeout(forceTimer);
-      if (settlementTimer) clearTimeout(settlementTimer);
       options.signal?.removeEventListener("abort", onAbort);
       resolve10(result);
     };
@@ -300373,20 +300428,27 @@ async function runCommand(command, args, options = {}) {
       terminate(new Error("command cancelled"));
     };
     options.signal?.addEventListener("abort", onAbort, { once: true });
+    if (options.signal?.aborted) onAbort();
     child.stdout?.on("data", (chunk) => {
       stdout = capture(stdout, chunk);
+      options.onStdout?.(chunk.toString());
     });
     child.stderr?.on("data", (chunk) => {
       stderr = capture(stderr, chunk);
+      options.onStderr?.(chunk.toString());
     });
     child.once("error", (error) => finish({ status: null, stdout, stderr, signal: null, error }));
-    child.once("close", (status, signal) => finish({ status, stdout, stderr, signal, ...stopError ? { error: stopError } : {} }));
+    child.once("close", (status, signal) => {
+      if (stopping) signalChild("SIGKILL");
+      finish({ status, stdout, stderr, signal, ...stopError ? { error: stopError } : {} });
+    });
     timer = setTimeout(() => {
       terminate(new Error(`command timed out after ${options.timeout ?? 15e3}ms`));
     }, options.timeout ?? 15e3);
     timer.unref?.();
   });
 }
+var runCommand = runUpdateCommand;
 function globalPackageCandidates(prefix) {
   return process.platform === "win32" ? [join15(prefix, "node_modules", "omnius", "package.json"), join15(prefix, "omnius", "package.json")] : [join15(prefix, "lib", "node_modules", "omnius", "package.json"), join15(prefix, "node_modules", "omnius", "package.json")];
 }
@@ -300448,71 +300510,38 @@ async function quiesceDaemonWithRetry(quiesce, attempts = 3, pauseMs = 250) {
   }
   return false;
 }
-function installGlobalPackageStreaming(input) {
-  return new Promise((resolve10) => {
-    const stderrTail = [];
-    let settled = false;
-    let timedOut = false;
-    const finish = (exitCode, error) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      resolve10({ exitCode, ...error ? { error } : {} });
-    };
-    const child = spawn2(
-      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", (code, signal) => {
-      const exitCode = code ?? -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 installGlobalPackageStreaming(input) {
+  const result = await runUpdateCommand(input.npmPath, [
+    "install",
+    "-g",
+    `omnius@${input.targetVersion}`,
+    "--prefer-online",
+    "--no-audit",
+    "--no-fund",
+    "--no-progress"
+  ], {
+    env: input.env,
+    signal: input.signal,
+    timeout: 5 * 6e4,
+    onStdout: (text2) => process.stdout.write(text2),
+    onStderr: (text2) => process.stderr.write(text2)
   });
+  const exitCode = result.status ?? -1;
+  return { exitCode, ...result.error || exitCode !== 0 ? {
+    error: result.error?.message || result.stderr.slice(-8e3).trim() || `npm install exited with ${result.signal || exitCode}`
+  } : {} };
 }
 async function runVerifiedUpdateTransaction(initial, dependencies, paths = resolveUpdatePaths()) {
   let state = initial;
   let daemonQuiesced = false;
+  let installStarted = false;
+  const throwIfCancelled = () => {
+    if (dependencies.signal?.aborted) throw new UpdateCancelledError();
+  };
+  const onCancel = () => {
+    if (state.status === "running") state = transition(state, { phase: "cancelling" }, paths);
+  };
+  dependencies.signal?.addEventListener("abort", onCancel, { once: true });
   const target = assertExactUpdateTarget(initial.target_version);
   const npmPath = resolveNpmPath();
   const env = {
@@ -300524,6 +300553,7 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     OMNIUS_UPDATE_COORDINATED: "1"
   };
   try {
+    throwIfCancelled();
     if (dependencies.quiesceDaemon) {
       state = transition(state, { phase: "daemon_quiescing" }, paths);
       if (!await quiesceDaemonWithRetry(dependencies.quiesceDaemon)) {
@@ -300532,20 +300562,25 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
         );
       }
       daemonQuiesced = true;
+      throwIfCancelled();
     }
-    const prefixProbe = await runCommand(npmPath, ["prefix", "-g"], { env, timeout: 1e4 });
+    const prefixProbe = await runCommand(npmPath, ["prefix", "-g"], { env, timeout: 1e4, signal: dependencies.signal });
+    throwIfCancelled();
     state = transition(state, {
       phase: "installing",
       npm_path: npmPath,
       ...prefixProbe.status === 0 && prefixProbe.stdout.trim() ? { npm_prefix: prefixProbe.stdout.trim() } : {}
     }, paths);
     const installer = dependencies.install ?? installGlobalPackageStreaming;
-    const installResult = await installer({ npmPath, targetVersion: target, env });
+    installStarted = true;
+    const installResult = await installer({ npmPath, targetVersion: target, env, signal: dependencies.signal });
     state = transition(state, { installer_exit_code: installResult.exitCode }, paths);
+    throwIfCancelled();
     if (installResult.exitCode !== 0) {
       throw new Error(installResult.error || `npm install exited with code ${installResult.exitCode}`);
     }
     const evidence = dependencies.inspectInstall ? await dependencies.inspectInstall(target, npmPath, env) : await inspectGlobalOmniusInstall(target, { npmPath, env });
+    throwIfCancelled();
     state = transition(state, {
       phase: "package_verified",
       npm_prefix: evidence.npmPrefix,
@@ -300559,8 +300594,10 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     let daemon = null;
     let restartAcknowledged = false;
     for (let attempt = 1; attempt <= 3; attempt++) {
+      throwIfCancelled();
       restartAcknowledged = await dependencies.restartDaemon(target, evidence.executablePath) || restartAcknowledged;
       daemon = await dependencies.observeDaemon();
+      throwIfCancelled();
       if (daemon?.bootVersion === target && daemon.bootPackageHash === evidence.packageHash) {
         break;
       }
@@ -300587,12 +300624,14 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
       daemon_boot_hash: daemon.bootPackageHash
     }, paths);
     if (state.tray_was_running && dependencies.restartTray) {
+      throwIfCancelled();
       state = transition(state, { phase: "tray_restarting" }, paths);
       if (!await dependencies.restartTray(evidence.executablePath)) {
         throw new Error("The package and daemon updated, but the running tray could not be relaunched");
       }
       state = transition(state, { tray_restarted: true }, paths);
     }
+    throwIfCancelled();
     const now = (/* @__PURE__ */ new Date()).toISOString();
     state = transition(state, {
       status: "completed",
@@ -300603,25 +300642,32 @@ async function runVerifiedUpdateTransaction(initial, dependencies, paths = resol
     }, paths);
     return state;
   } catch (error) {
+    const cancelled = error instanceof UpdateCancelledError || dependencies.signal?.aborted === true;
     const message = error instanceof Error ? error.message : String(error);
     let recoveryNote;
     if (daemonQuiesced && dependencies.recoverDaemon) {
+      state = transition(state, { phase: "recovering" }, paths);
       try {
         const recovered = await dependencies.recoverDaemon();
-        recoveryNote = recovered ? "The prior daemon was restarted after the failed update." : "The daemon could not be recovered automatically after the failed update.";
+        recoveryNote = recovered ? "The daemon was restarted after the interrupted update." : "The daemon could not be recovered automatically after the failed update.";
       } catch (recoveryError) {
         recoveryNote = `Daemon recovery failed: ${recoveryError instanceof Error ? recoveryError.message : String(recoveryError)}`;
       }
     }
     state = transition(state, {
-      status: "failed",
-      phase: "failed",
+      status: cancelled ? "cancelled" : "failed",
+      phase: cancelled ? "cancelled" : "failed",
       completed_at: (/* @__PURE__ */ new Date()).toISOString(),
-      error: message,
-      remediation: [permissionRemediation(message), recoveryNote].filter(Boolean).join(" ") || void 0
+      error: cancelled ? "Update cancelled after the owned operation settled." : message,
+      remediation: [
+        cancelled && installStarted ? "Package files may have changed. No rollback was performed; verify the installed version before retrying." : void 0,
+        permissionRemediation(message),
+        recoveryNote
+      ].filter(Boolean).join(" ") || void 0
     }, paths);
     return state;
   } finally {
+    dependencies.signal?.removeEventListener("abort", onCancel);
     releaseUpdateLock(paths, initial.operation_id);
   }
 }
@@ -300967,20 +301013,25 @@ async function main() {
   const port = Number(new URL(endpoint).port || "11435");
   const trayWasRunning = state.tray_was_running || (await getTrayStatus(endpoint)).running;
   state.tray_was_running = trayWasRunning;
+  const cancellation = watchUpdateCancellation(operationId, paths);
   const finalState = await runVerifiedUpdateTransaction(
     state,
     {
       quiesceDaemon: () => quiesceDaemonForUpdate(port),
       restartDaemon: (expected, executable) => restartDaemon(port, expected, executable),
-      recoverDaemon: () => restartDaemon(port, target),
+      recoverDaemon: async () => {
+        await restartDaemon(port);
+        return Boolean(await getDaemonReportedIdentity(port));
+      },
       observeDaemon: async () => {
         const identity = await getDaemonReportedIdentity(port);
         return identity ? { bootVersion: identity.bootVersion, bootPackageHash: identity.bootPackageHash } : null;
       },
-      restartTray: trayWasRunning ? (executable) => restartTrayWithInstalledExecutable(executable, endpoint) : void 0
+      restartTray: trayWasRunning ? (executable) => restartTrayWithInstalledExecutable(executable, endpoint) : void 0,
+      signal: cancellation.signal
     },
     paths
-  );
+  ).finally(() => cancellation.close());
   process.exitCode = finalState.status === "completed" ? 0 : 1;
 }
 void main().catch((error) => {