akm-cli 0.9.0-rc.1 → 0.9.0-rc.13

package/dist/core/config/config-io.js

@@ -15,9 +15,9 @@
 import fs from "node:fs";
 import path from "node:path";
 import { sleepSync } from "../../runtime.js";
-import { writeFileAtomic } from "../common.js";
+import { MAX_CONFIG_FILE_BYTES, readTextFileWithLimit, writeFileAtomic } from "../common.js";
 import { ConfigError } from "../errors.js";
-import { probeLock, releaseLock, tryAcquireLockSync } from "../file-lock.js";
+import { createLockPayload, probeLock, reclaimStaleLock, releaseLock, tryAcquireLockSync } from "../file-lock.js";
 import { getCacheDir, getConfigDir } from "../paths.js";
 /**
  * Read the raw text of a config file. Returns `undefined` when the file does
@@ -25,7 +25,7 @@ import { getCacheDir, getConfigDir } from "../paths.js";
  */
 export function readConfigText(configPath) {
     try {
-        return fs.readFileSync(configPath, "utf8");
+        return readTextFileWithLimit(configPath, MAX_CONFIG_FILE_BYTES, "Config file");
     }
     catch (err) {
         if (err.code === "ENOENT")
@@ -80,7 +80,7 @@ export function writeConfigAtomic(configPath, config) {
 }
 /** Maximum number of timestamped config backups to retain (#459). */
 const MAX_CONFIG_BACKUPS = 5;
-export function backupExistingConfig(configPath) {
+export function backupExistingConfig(configPath, now = new Date()) {
     if (!fs.existsSync(configPath))
         return undefined;
     const backupDir = path.join(getCacheDir(), "config-backups");
@@ -89,10 +89,22 @@ export function backupExistingConfig(configPath) {
     // the copy→chmod window. chmod again to tighten a dir from an older version.
     fs.mkdirSync(backupDir, { recursive: true, mode: 0o700 });
     fs.chmodSync(backupDir, 0o700);
-    const timestamp = new Date().toISOString().replace(/[.:]/g, "-");
-    const timestamped = path.join(backupDir, `config-${timestamp}.json`);
+    const timestamp = now.toISOString().replace(/[.:]/g, "-");
+    let sequence = 0;
+    let timestamped;
+    while (true) {
+        timestamped = path.join(backupDir, `config-${timestamp}${sequence === 0 ? "" : `-${sequence}`}.json`);
+        try {
+            fs.copyFileSync(configPath, timestamped, fs.constants.COPYFILE_EXCL);
+            break;
+        }
+        catch (error) {
+            if (error.code !== "EEXIST")
+                throw error;
+            sequence++;
+        }
+    }
     const latest = path.join(backupDir, "config.latest.json");
-    fs.copyFileSync(configPath, timestamped);
     fs.copyFileSync(configPath, latest);
     // 08-F4: a config backup carries the same sensitive fields as the live config
     // (endpoints, tokens). `copyFileSync` inherits the source's (often 0644) mode,
@@ -141,10 +153,21 @@ function pruneOldBackups(backupDir) {
  * predictable for debugging. Uses $CONFIG (not $DATA) because config.json
  * itself lives in $CONFIG — they should fail together if the dir is read-only.
  */
-function getConfigLockPath() {
+export function getConfigLockPath() {
     return path.join(getConfigDir(), "config.json.lck");
 }
-const CONFIG_LOCK_MAX_RETRIES = 10;
+// Total wait budget for a CONTENDED lock: retries × delay. An abandoned lock
+// is not covered by this budget — it is reclaimed by the stale-lock probe
+// below — so this only bounds how long a caller queues behind live writers.
+//
+// 10 × 50ms (500ms) was too thin: N concurrent `akm config set` processes
+// serialize on this lock, so the last one in line waits for all N-1 holders.
+// On a loaded machine (CI runs four test shards in parallel) eight contenders
+// exhausted the budget and one exited with "Timed out waiting for config
+// lock", which is a spurious failure — the lock was healthy and simply busy.
+// 2s gives real concurrent use headroom while still failing promptly against a
+// genuinely wedged (but non-stale) holder.
+const CONFIG_LOCK_MAX_RETRIES = 40;
 const CONFIG_LOCK_RETRY_DELAY_MS = 50;
 /**
  * Block the current thread for `ms` without busy-spinning (H8). Delegates to
@@ -157,8 +180,8 @@ function sleepSyncMs(ms) {
 /**
  * Acquire an exclusive sentinel around config writes.
  *
- * Returns a release function. Best-effort: when all retries are exhausted the
- * write proceeds unlocked rather than erroring (same posture as lockfile.ts).
+ * Returns a release function. Acquisition is fail-closed: config mutation may
+ * never continue without owning the lock that protects its read/merge/write.
  */
 export function acquireConfigLock() {
     const lockPath = getConfigLockPath();
@@ -170,16 +193,16 @@ export function acquireConfigLock() {
     }
     for (let attempt = 0; attempt < CONFIG_LOCK_MAX_RETRIES; attempt++) {
         try {
-            if (tryAcquireLockSync(lockPath, String(process.pid))) {
-                return () => releaseLock(lockPath);
+            const ownership = tryAcquireLockSync(lockPath, createLockPayload());
+            if (ownership) {
+                return () => releaseLock(ownership);
             }
         }
-        catch {
-            // Non-EEXIST error (permissions, etc.) — bail out and proceed unlocked.
-            break;
+        catch (error) {
+            throw new ConfigError(`Unable to acquire config lock at ${lockPath}: ${error instanceof Error ? error.message : String(error)}`, "INVALID_CONFIG_FILE");
         }
-        if (probeLock(lockPath).state === "stale") {
-            releaseLock(lockPath);
+        const probe = probeLock(lockPath);
+        if (probe.state === "stale" && reclaimStaleLock(lockPath, probe)) {
             continue; // Reclaimed — retry immediately.
         }
         if (attempt < CONFIG_LOCK_MAX_RETRIES - 1) {
@@ -195,8 +218,7 @@ export function acquireConfigLock() {
             sleepSyncMs(CONFIG_LOCK_RETRY_DELAY_MS);
         }
     }
-    // Best-effort: proceed without lock.
-    return () => { };
+    throw new ConfigError(`Timed out waiting for config lock at ${lockPath}. Another AKM process may be updating config.`, "INVALID_CONFIG_FILE");
 }
 /**
  * Run `fn` inside the config write lock. Always releases the lock.
@@ -210,114 +232,6 @@ export function withConfigLock(fn) {
         release();
     }
 }
-// ── Unified diff helper ──────────────────────────────────────────────────────
-/**
- * Produce a minimal unified diff between `before` and `after` text.
- * Uses LCS-based diff with 2-line context. Returns an empty string when the
- * inputs are identical. `label` is used as the path in the diff header.
- *
- * Designed for config files (typically < 200 lines). O(m*n) in line count.
- */
-export function unifiedDiff(before, after, label) {
-    if (before === after)
-        return "";
-    const a = before.split("\n");
-    const b = after.split("\n");
-    const eqPairs = lcsLinePairs(a, b);
-    const CONTEXT = 2;
-    const ops = [];
-    let ai = 0;
-    let bi = 0;
-    let pi = 0;
-    while (ai < a.length || bi < b.length) {
-        const eq = eqPairs[pi];
-        if (eq && eq.ai === ai && eq.bi === bi) {
-            ops.push({ type: "eq", line: a[ai], ai, bi });
-            ai++;
-            bi++;
-            pi++;
-        }
-        else if (ai < a.length && (!eq || ai < eq.ai)) {
-            ops.push({ type: "del", line: a[ai], ai, bi });
-            ai++;
-        }
-        else {
-            ops.push({ type: "add", line: b[bi], ai, bi });
-            bi++;
-        }
-    }
-    // Find changed op indices
-    const changed = new Set(ops.map((o, i) => (o.type !== "eq" ? i : -1)).filter((i) => i >= 0));
-    if (changed.size === 0)
-        return "";
-    // Determine which equal lines to include as context
-    const include = new Set();
-    for (const ci of changed) {
-        for (let k = Math.max(0, ci - CONTEXT); k <= Math.min(ops.length - 1, ci + CONTEXT); k++) {
-            include.add(k);
-        }
-    }
-    // Collect hunks
-    const header = [`--- ${label} (before)`, `+++ ${label} (after)`];
-    const out = [];
-    let hunkOps = [];
-    let prevIncluded = false;
-    function flushHunk() {
-        if (hunkOps.length === 0)
-            return;
-        const delStart = hunkOps.find((o) => o.type !== "add")?.ai ?? 0;
-        const addStart = hunkOps.find((o) => o.type !== "del")?.bi ?? 0;
-        const countA = hunkOps.filter((o) => o.type !== "add").length;
-        const countB = hunkOps.filter((o) => o.type !== "del").length;
-        out.push(`@@ -${delStart + 1},${countA} +${addStart + 1},${countB} @@`);
-        for (const op of hunkOps) {
-            const ch = op.type === "eq" ? " " : op.type === "del" ? "-" : "+";
-            out.push(`${ch}${op.line}`);
-        }
-        hunkOps = [];
-    }
-    for (let k = 0; k < ops.length; k++) {
-        if (include.has(k)) {
-            hunkOps.push(ops[k]);
-            prevIncluded = true;
-        }
-        else if (prevIncluded) {
-            flushHunk();
-            prevIncluded = false;
-        }
-    }
-    flushHunk();
-    return out.length > 0 ? [...header, ...out].join("\n") : "";
-}
-function lcsLinePairs(a, b) {
-    const m = a.length;
-    const n = b.length;
-    if (m === 0 || n === 0)
-        return [];
-    const dp = Array.from({ length: m + 1 }, () => new Array(n + 1).fill(0));
-    for (let i = 1; i <= m; i++) {
-        for (let j = 1; j <= n; j++) {
-            dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] + 1 : Math.max(dp[i - 1][j], dp[i][j - 1]);
-        }
-    }
-    const result = [];
-    let i = m;
-    let j = n;
-    while (i > 0 && j > 0) {
-        if (a[i - 1] === b[j - 1]) {
-            result.unshift({ ai: i - 1, bi: j - 1 });
-            i--;
-            j--;
-        }
-        else if (dp[i - 1][j] > dp[i][j - 1]) {
-            i--;
-        }
-        else {
-            j--;
-        }
-    }
-    return result;
-}
 /**
  * Strip JavaScript-style comments from a JSON string (JSONC support).
  * Handles `//` line comments and `/* *​/` block comments while preserving