commandmate 0.10.4 → 0.11.0

package/dist/lib/app-update/update-lock.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Update Lock
+ * Issue #1198: guard `POST /api/app/update` against concurrent self-updates.
+ *
+ * Design constraints:
+ * - Acquisition is a single O_EXCL create (mirrors PidManager.writePid), so two
+ *   concurrent requests cannot both win.
+ * - A successful update restarts the server, so nothing survives to release the
+ *   lock. Timeout expiry is therefore the primary release path, and
+ *   releaseUpdateLock() exists only for the spawn-failed case.
+ *
+ * @module lib/app-update/update-lock
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATE_LOCK_TIMEOUT_MS = exports.UPDATE_LOCK_FILENAME = void 0;
+exports.getUpdateLockPath = getUpdateLockPath;
+exports.acquireUpdateLock = acquireUpdateLock;
+exports.releaseUpdateLock = releaseUpdateLock;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// Relative (not '@/') so the CLI build (tsconfig.cli.json has no path alias and
+// no tsc-alias step) can pull this module into `commandmate update --relaunch-npx`
+// to release the lock on an npx abort path (Issue #1395 §5.2).
+const install_context_1 = require("../../cli/utils/install-context");
+/** Lock file name inside the config directory */
+exports.UPDATE_LOCK_FILENAME = 'update.lock';
+/**
+ * Age after which a lock is considered abandoned.
+ * `commandmate update` takes tens of seconds (npm install dominates); 10 minutes
+ * is well clear of that while still recovering from a killed update process.
+ */
+exports.UPDATE_LOCK_TIMEOUT_MS = 10 * 60 * 1000;
+/**
+ * Absolute path of the update lock file.
+ */
+function getUpdateLockPath() {
+    return (0, path_1.join)((0, install_context_1.ensureConfigDir)(), exports.UPDATE_LOCK_FILENAME);
+}
+/**
+ * Whether an existing lock is old enough to reclaim.
+ * An unreadable or malformed lock counts as stale: it can never expire on its
+ * own, so treating it as held would block updates permanently.
+ */
+function isStale(lockPath, now) {
+    try {
+        const parsed = JSON.parse((0, fs_1.readFileSync)(lockPath, 'utf-8'));
+        const startedAt = parsed.startedAt;
+        if (typeof startedAt !== 'number' || !Number.isFinite(startedAt)) {
+            return true;
+        }
+        return now - startedAt > exports.UPDATE_LOCK_TIMEOUT_MS;
+    }
+    catch {
+        return true;
+    }
+}
+/**
+ * Create the lock file, failing if it already exists.
+ *
+ * @returns true when this call created the file
+ */
+function tryCreate(lockPath, now) {
+    let fd;
+    try {
+        fd = (0, fs_1.openSync)(lockPath, fs_1.constants.O_CREAT | fs_1.constants.O_EXCL | fs_1.constants.O_WRONLY, 0o600);
+    }
+    catch {
+        return false;
+    }
+    try {
+        const data = { startedAt: now, pid: process.pid };
+        (0, fs_1.writeSync)(fd, JSON.stringify(data));
+        return true;
+    }
+    finally {
+        (0, fs_1.closeSync)(fd);
+    }
+}
+/**
+ * Take the update lock.
+ *
+ * @param now - Current epoch ms (injectable for tests)
+ * @returns true when the caller now holds the lock, false when an update is in progress
+ */
+function acquireUpdateLock(now = Date.now()) {
+    const lockPath = getUpdateLockPath();
+    if (tryCreate(lockPath, now)) {
+        return true;
+    }
+    if (!isStale(lockPath, now)) {
+        return false;
+    }
+    // Reclaim: unlink then re-create. A concurrent reclaimer loses the O_EXCL
+    // race and correctly reports "in progress" rather than spawning a second update.
+    try {
+        (0, fs_1.unlinkSync)(lockPath);
+    }
+    catch {
+        return false;
+    }
+    return tryCreate(lockPath, now);
+}
+/**
+ * Drop the update lock.
+ * Only meaningful when the update never started (spawn failure): a started
+ * update replaces this process, so the lock outlives it until it expires.
+ */
+function releaseUpdateLock() {
+    try {
+        (0, fs_1.unlinkSync)(getUpdateLockPath());
+    }
+    catch {
+        // Already gone (expired and reclaimed elsewhere) — nothing to do.
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "commandmate",
-  "version": "0.10.4",
+  "version": "0.11.0",
   "description": "A local control plane for agent CLIs — orchestration and visibility for Claude Code, Codex, Gemini CLI, and more across Git worktrees",
   "keywords": [
     "claude-code",