herdr-remote 0.2.29 → 0.2.30

package/dist/update-command.js

@@ -12,6 +12,7 @@ import { cliEntryPoint } from './keepalive/environment.js';
 import { servicesRunning, startAll, stopAll } from './lifecycle.js';
 import { checkForRelayUpdate, performRelayUpdate } from './relay-updater.js';
 import { checkForUpdate, performUpdate } from './updater.js';
+import { heldByAnotherProcess } from './updater/in-place.js';
 const RESTART_TIMEOUT_MS = 120_000;
 function restartWithInstalledRelease() {
     const result = spawnSync(process.execPath, [cliEntryPoint(), 'restart', '--json'], {
@@ -91,7 +92,7 @@ export async function runUpdate(t, options = {}) {
         report(t(result.errorKey ?? 'update.errorFailed', { version, installed: result.installed ?? '' }));
         if (result.summary)
             report(t('update.errorFailedDetail', { message: result.summary }));
-        if (platform === 'win32' && /\b(EBUSY|EPERM)\b/.test(result.output ?? '')) {
+        if (platform === 'win32' && heldByAnotherProcess(result.output)) {
             report(t('update.errorBusy'));
         }
         const { errorKey, summary } = result;

package/dist/updater/in-place.js

@@ -0,0 +1,83 @@
+// Installing a release when npm cannot replace this one on Windows.
+//
+// npm replaces a global package by renaming its directory, and Windows refuses
+// while any process works in that directory or runs a file from it: a shell or
+// editor left there, a program an older release started. Nobody can find and
+// stop them all. The files inside can still be replaced, so npm installs the
+// release into a staging prefix and it is copied over this one file by file.
+import fs from 'node:fs';
+import path from 'node:path';
+import { PACKAGE_ROOT, stateDir } from '../paths.js';
+const HELD_FILE_CODES = ['EBUSY', 'EPERM', 'EACCES'];
+/** npm could not rename the package directory because something holds it. */
+export function heldByAnotherProcess(npmOutput) {
+    return /\b(EBUSY|EPERM)\b/.test(npmOutput ?? '');
+}
+function replaceFile(source, target, copyFile) {
+    try {
+        copyFile(source, target);
+    }
+    catch (error) {
+        if (!HELD_FILE_CODES.includes(error.code ?? ''))
+            throw error;
+        // A running program or a loaded module cannot be overwritten, but it can be renamed.
+        fs.renameSync(target, `${target}.${process.pid}.old`);
+        copyFile(source, target);
+    }
+}
+/** Make `target` hold what `source` holds, without renaming any directory. */
+export function replaceTree(source, target, copyFile = fs.copyFileSync) {
+    fs.mkdirSync(target, { recursive: true });
+    // Lowercase because Windows reads names that differ only in case as one file.
+    const kept = new Set();
+    for (const entry of fs.readdirSync(source, { withFileTypes: true })) {
+        kept.add(entry.name.toLowerCase());
+        const from = path.join(source, entry.name);
+        const to = path.join(target, entry.name);
+        const existing = fs.lstatSync(to, { throwIfNoEntry: false });
+        if (existing && existing.isDirectory() !== entry.isDirectory())
+            fs.rmSync(to, { recursive: true, force: true });
+        if (entry.isDirectory())
+            replaceTree(from, to, copyFile);
+        else
+            replaceFile(from, to, copyFile);
+    }
+    for (const name of fs.readdirSync(target)) {
+        if (kept.has(name.toLowerCase()))
+            continue;
+        try {
+            fs.rmSync(path.join(target, name), { recursive: true, force: true });
+        }
+        catch {
+            // Still held, like a file renamed aside above; the next update removes it.
+        }
+    }
+}
+/** Run the failed `npm install -g` again into a staging prefix, then copy the result over `target`. */
+export async function installInPlace(args, run, { target = PACKAGE_ROOT, stage = path.join(stateDir(), 'update-stage'), platform = process.platform, } = {}) {
+    fs.rmSync(stage, { recursive: true, force: true });
+    try {
+        const result = await run([...args, '--prefix', stage]);
+        if (!result.ok)
+            return result;
+        // npm's global layout under a prefix.
+        const modules = platform === 'win32'
+            ? path.join(stage, 'node_modules')
+            : path.join(stage, 'lib', 'node_modules');
+        try {
+            replaceTree(path.join(modules, path.basename(target)), target);
+        }
+        catch (error) {
+            return { ok: false, output: `${result.output}\n${error.message}` };
+        }
+        return result;
+    }
+    finally {
+        try {
+            fs.rmSync(stage, { recursive: true, force: true });
+        }
+        catch {
+            // A stage left behind is emptied before the next one is used.
+        }
+    }
+}

package/dist/updater.js

@@ -9,6 +9,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { spawn } from 'node:child_process';
 import { PACKAGE_ROOT } from './paths.js';
+import { heldByAnotherProcess, installInPlace } from './updater/in-place.js';
 import { runNpm } from './updater/npm.js';
 const PACKAGE_NAME = 'herdr-remote';
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org';
@@ -284,6 +285,8 @@ const VERSION_PATTERN = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/;
  *   version although its dist-tag already points at it: npm answers ETARGET.
  *   That is a wait, not a failure, so it is retried a few times, then the next
  *   registry that carries the version is tried.
+ * - On Windows, when something holds the package directory so npm cannot
+ *   rename it, the release is copied over it instead.
  * - Success is what is on disk afterwards, not npm's exit code.
  */
 async function performUpdate({ spawnImpl = spawn, timeoutMs = 180_000, 
@@ -292,7 +295,7 @@ async function performUpdate({ spawnImpl = spawn, timeoutMs = 180_000,
 installKindImpl = installKind, 
 // The registries that reported `version`, preferred first. Empty means
 // "whatever npm is configured with", which is right when no check has run.
-registry = '', sources = [], version = null, attempts = 3, retryDelayMs = 15_000, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), readInstalledVersion = installedVersionOnDisk, onAttempt = () => { }, } = {}) {
+registry = '', sources = [], version = null, attempts = 3, retryDelayMs = 15_000, sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)), readInstalledVersion = installedVersionOnDisk, onAttempt = () => { }, platform = process.platform, inPlace = installInPlace, } = {}) {
     const kind = installKindImpl();
     if (kind !== 'npm')
         return { ok: false, errorKey: `update.cannot.${kind}` };
@@ -314,7 +317,9 @@ registry = '', sources = [], version = null, attempts = 3, retryDelayMs = 15_000
             const args = ['install', '-g', spec, '--prefer-online'];
             if (source)
                 args.push('--registry', source);
-            const result = await runNpm(spawnImpl, args, timeoutMs);
+            let result = await runNpm(spawnImpl, args, timeoutMs);
+            if (!result.ok && platform === 'win32' && heldByAnotherProcess(result.output))
+                result = await inPlace(args, (stagedArgs) => runNpm(spawnImpl, stagedArgs, timeoutMs));
             if (result.ok) {
                 const installed = readInstalledVersion();
                 if (target && installed && compareVersions(installed, target) < 0) {

package/herdr-plugin.toml

@@ -1,6 +1,6 @@
 id = "herdr.remote.web"
 name = "Herdr Remote Web"
-version = "0.2.29"
+version = "0.2.30"
 min_herdr_version = "0.9.1"
 description = "Browser access to Herdr workspaces via local or self-hosted relay"
 platforms = ["linux", "macos", "windows"]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "herdr-remote",
-  "version": "0.2.29",
+  "version": "0.2.30",
   "description": "Browser access to Herdr workspaces: plugin, host connector, and configuration TUI",
   "license": "MIT",
   "type": "module",