blun-king-cli 9.1.564 → 9.1.566

package/agent-spine-plugin/src/lib/owned-file-lock.js

@@ -1,143 +1,143 @@
-import { randomUUID } from "node:crypto";
-import { open, readFile, stat, unlink, utimes } from "node:fs/promises";
-import { isFileLockContention, isTransientLockMetadataError } from "./filesystem-retry.js";
-
-const LOCK_SCHEMA = "agentspine.owned-file-lock/v1";
-
-function delay(milliseconds) {
-  return new Promise((resolve) => setTimeout(resolve, milliseconds));
-}
-
-function lockPayload(token, acquiredAt, leaseMs) {
-  return {
-    schema: LOCK_SCHEMA,
-    token,
-    acquiredAt,
-    leaseMs,
-    authority: "state-coordination-only"
-  };
-}
-
-async function readOwner(path) {
-  try {
-    const value = JSON.parse(await readFile(path, "utf8"));
-    if (!value || typeof value !== "object" || Array.isArray(value)
-      || value.schema !== LOCK_SCHEMA || typeof value.token !== "string") return null;
-    return value;
-  } catch (error) {
-    if (error.code === "ENOENT" || error instanceof SyntaxError) return null;
-    throw error;
-  }
-}
-
-function sameFile(left, right) {
-  return left.dev === right.dev && left.ino === right.ino && left.size === right.size
-    && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
-}
-
-async function removeStaleLock(path, staleAfterMs) {
-  let before;
-  try {
-    before = await stat(path);
-  } catch (error) {
-    if (isTransientLockMetadataError(error)) return false;
-    throw error;
-  }
-  if (Date.now() - before.mtimeMs <= staleAfterMs) return false;
-  await readOwner(path);
-  let after;
-  try {
-    after = await stat(path);
-  } catch (error) {
-    if (isTransientLockMetadataError(error)) return false;
-    throw error;
-  }
-  if (!sameFile(before, after) || Date.now() - after.mtimeMs <= staleAfterMs) return false;
-  try {
-    await unlink(path);
-    return true;
-  } catch (error) {
-    if (isFileLockContention(error) || isTransientLockMetadataError(error)) return false;
-    throw error;
-  }
-}
-
-export async function withOwnedFileLock(path, task, {
-  staleAfterMs = 15000,
-  heartbeatIntervalMs = 1000,
-  retryDelayMs = 25,
-  maxAttempts = 80
-} = {}) {
-  if (typeof task !== "function") throw new Error("owned file lock requires a task");
-  if (!Number.isInteger(staleAfterMs) || staleAfterMs < 50
-    || !Number.isInteger(heartbeatIntervalMs) || heartbeatIntervalMs < 10
-    || heartbeatIntervalMs * 3 >= staleAfterMs
-    || !Number.isInteger(retryDelayMs) || retryDelayMs < 1
-    || !Number.isInteger(maxAttempts) || maxAttempts < 1) {
-    throw new Error("owned file lock timing is invalid");
-  }
-  const token = randomUUID();
-  const acquiredAt = new Date().toISOString();
-  let acquired = false;
-  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
-    let handle;
-    try {
-      handle = await open(path, "wx", 0o600);
-      const payload = `${JSON.stringify(lockPayload(token, acquiredAt, staleAfterMs))}\n`;
-      await handle.writeFile(payload, "utf8");
-      acquired = true;
-      break;
-    } catch (error) {
-      if (!isFileLockContention(error)) {
-        if (handle) {
-          await handle.close();
-          handle = null;
-          await unlink(path).catch((cleanupError) => {
-            if (cleanupError.code !== "ENOENT") error.cleanupError = cleanupError;
-          });
-        }
-        throw error;
-      }
-      await removeStaleLock(path, staleAfterMs);
-      if (attempt + 1 < maxAttempts) await delay(retryDelayMs);
-    } finally {
-      await handle?.close();
-    }
-  }
-  if (!acquired) throw new Error("state is busy; retry shortly");
-
-  let ownershipError = null;
-  let heartbeat = Promise.resolve();
-  const assertOwned = async () => {
-    if (ownershipError) throw ownershipError;
-    const owner = await readOwner(path);
-    if (!owner || owner.token !== token) {
-      ownershipError = new Error("state lock ownership was lost; mutation aborted");
-      throw ownershipError;
-    }
-  };
-  const renew = async () => {
-    await assertOwned();
-    const now = new Date();
-    await utimes(path, now, now);
-  };
-  const timer = setInterval(() => {
-    heartbeat = heartbeat.then(renew).catch((error) => { ownershipError ||= error; });
-  }, heartbeatIntervalMs);
-  timer.unref?.();
-
-  try {
-    const result = await task({ token, acquiredAt, assertOwned });
-    await assertOwned();
-    return result;
-  } finally {
-    clearInterval(timer);
-    await heartbeat;
-    const owner = await readOwner(path).catch(() => null);
-    if (owner?.token === token) {
-      await unlink(path).catch((error) => {
-        if (error.code !== "ENOENT") throw error;
-      });
-    }
-  }
-}
+import { randomUUID } from "node:crypto";
+import { open, readFile, stat, unlink, utimes } from "node:fs/promises";
+import { isFileLockContention, isTransientLockMetadataError } from "./filesystem-retry.js";
+
+const LOCK_SCHEMA = "agentspine.owned-file-lock/v1";
+
+function delay(milliseconds) {
+  return new Promise((resolve) => setTimeout(resolve, milliseconds));
+}
+
+function lockPayload(token, acquiredAt, leaseMs) {
+  return {
+    schema: LOCK_SCHEMA,
+    token,
+    acquiredAt,
+    leaseMs,
+    authority: "state-coordination-only"
+  };
+}
+
+async function readOwner(path) {
+  try {
+    const value = JSON.parse(await readFile(path, "utf8"));
+    if (!value || typeof value !== "object" || Array.isArray(value)
+      || value.schema !== LOCK_SCHEMA || typeof value.token !== "string") return null;
+    return value;
+  } catch (error) {
+    if (error.code === "ENOENT" || error instanceof SyntaxError) return null;
+    throw error;
+  }
+}
+
+function sameFile(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size
+    && left.mtimeMs === right.mtimeMs && left.ctimeMs === right.ctimeMs;
+}
+
+async function removeStaleLock(path, staleAfterMs) {
+  let before;
+  try {
+    before = await stat(path);
+  } catch (error) {
+    if (isTransientLockMetadataError(error)) return false;
+    throw error;
+  }
+  if (Date.now() - before.mtimeMs <= staleAfterMs) return false;
+  await readOwner(path);
+  let after;
+  try {
+    after = await stat(path);
+  } catch (error) {
+    if (isTransientLockMetadataError(error)) return false;
+    throw error;
+  }
+  if (!sameFile(before, after) || Date.now() - after.mtimeMs <= staleAfterMs) return false;
+  try {
+    await unlink(path);
+    return true;
+  } catch (error) {
+    if (isFileLockContention(error) || isTransientLockMetadataError(error)) return false;
+    throw error;
+  }
+}
+
+export async function withOwnedFileLock(path, task, {
+  staleAfterMs = 15000,
+  heartbeatIntervalMs = 1000,
+  retryDelayMs = 25,
+  maxAttempts = 80
+} = {}) {
+  if (typeof task !== "function") throw new Error("owned file lock requires a task");
+  if (!Number.isInteger(staleAfterMs) || staleAfterMs < 50
+    || !Number.isInteger(heartbeatIntervalMs) || heartbeatIntervalMs < 10
+    || heartbeatIntervalMs * 3 >= staleAfterMs
+    || !Number.isInteger(retryDelayMs) || retryDelayMs < 1
+    || !Number.isInteger(maxAttempts) || maxAttempts < 1) {
+    throw new Error("owned file lock timing is invalid");
+  }
+  const token = randomUUID();
+  const acquiredAt = new Date().toISOString();
+  let acquired = false;
+  for (let attempt = 0; attempt < maxAttempts; attempt += 1) {
+    let handle;
+    try {
+      handle = await open(path, "wx", 0o600);
+      const payload = `${JSON.stringify(lockPayload(token, acquiredAt, staleAfterMs))}\n`;
+      await handle.writeFile(payload, "utf8");
+      acquired = true;
+      break;
+    } catch (error) {
+      if (!isFileLockContention(error)) {
+        if (handle) {
+          await handle.close();
+          handle = null;
+          await unlink(path).catch((cleanupError) => {
+            if (cleanupError.code !== "ENOENT") error.cleanupError = cleanupError;
+          });
+        }
+        throw error;
+      }
+      await removeStaleLock(path, staleAfterMs);
+      if (attempt + 1 < maxAttempts) await delay(retryDelayMs);
+    } finally {
+      await handle?.close();
+    }
+  }
+  if (!acquired) throw new Error("state is busy; retry shortly");
+
+  let ownershipError = null;
+  let heartbeat = Promise.resolve();
+  const assertOwned = async () => {
+    if (ownershipError) throw ownershipError;
+    const owner = await readOwner(path);
+    if (!owner || owner.token !== token) {
+      ownershipError = new Error("state lock ownership was lost; mutation aborted");
+      throw ownershipError;
+    }
+  };
+  const renew = async () => {
+    await assertOwned();
+    const now = new Date();
+    await utimes(path, now, now);
+  };
+  const timer = setInterval(() => {
+    heartbeat = heartbeat.then(renew).catch((error) => { ownershipError ||= error; });
+  }, heartbeatIntervalMs);
+  timer.unref?.();
+
+  try {
+    const result = await task({ token, acquiredAt, assertOwned });
+    await assertOwned();
+    return result;
+  } finally {
+    clearInterval(timer);
+    await heartbeat;
+    const owner = await readOwner(path).catch(() => null);
+    if (owner?.token === token) {
+      await unlink(path).catch((error) => {
+        if (error.code !== "ENOENT") throw error;
+      });
+    }
+  }
+}

package/agent-spine-plugin/src/lib/paths.js

@@ -1,109 +1,109 @@
-import { createHash } from "node:crypto";
-import { realpathSync } from "node:fs";
-import { homedir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { lstat, mkdir, realpath } from "node:fs/promises";
-
-export async function canonicalPath(input = process.cwd()) {
-  return realpath(resolve(input));
-}
-
-export async function findProjectRoot(input = process.cwd()) {
-  if (process.env.AGENTSPINE_ROOT) return canonicalPath(process.env.AGENTSPINE_ROOT);
-  let cursor = await canonicalPath(input);
-  while (true) {
-    try {
-      await lstat(join(cursor, ".git"));
-      return cursor;
-    } catch (error) {
-      if (error.code !== "ENOENT") throw error;
-    }
-    const parent = dirname(cursor);
-    if (parent === cursor) return canonicalPath(input);
-    cursor = parent;
-  }
-}
-
-export function isInside(parent, child, pathApi = { relative, isAbsolute, sep }) {
-  const value = pathApi.relative(parent, child);
-  return value === "" || (!pathApi.isAbsolute(value) && !value.startsWith(`..${pathApi.sep}`) && value !== "..");
-}
-
-export function ancestorsBetween(root, cwd) {
-  const result = [];
-  let cursor = resolve(cwd);
-  while (isInside(root, cursor)) {
-    result.push(cursor);
-    if (cursor === root) break;
-    const next = dirname(cursor);
-    if (next === cursor) break;
-    cursor = next;
-  }
-  return result.reverse();
-}
-
-export function stateRoot(env = process.env) {
-  if (env.AGENTSPINE_STATE_DIR) return resolve(env.AGENTSPINE_STATE_DIR);
-  if (process.platform === "win32") {
-    return join(env.LOCALAPPDATA || env.APPDATA || homedir(), "AgentSpine");
-  }
-  return join(env.XDG_STATE_HOME || join(homedir(), ".local", "state"), "agentspine");
-}
-
-export function comparablePath(value) {
-  let cursor = resolve(value);
-  const missing = [];
-  let canonical = cursor;
-  while (true) {
-    try {
-      canonical = realpathSync.native(cursor);
-      break;
-    } catch (error) {
-      if (error.code !== "ENOENT") break;
-      const parent = dirname(cursor);
-      if (parent === cursor) break;
-      missing.unshift(basename(cursor));
-      cursor = parent;
-    }
-  }
-  canonical = join(canonical, ...missing);
-  return canonical.replace(/[\\/]+$/, "");
-}
-
-function samePath(left, right) {
-  const normalize = comparablePath;
-  const a = normalize(left);
-  const b = normalize(right);
-  return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
-}
-
-export function isUserHomeRoot(root, env = process.env) {
-  const candidates = [homedir(), env.HOME, env.USERPROFILE,
-    env.HOMEDRIVE && env.HOMEPATH ? `${env.HOMEDRIVE}${env.HOMEPATH}` : null]
-    .filter((value) => typeof value === "string" && value && isAbsolute(value));
-  return candidates.some((candidate) => samePath(root, candidate));
-}
-
-export function statePathIsScanExcluded(catalog, path, env = process.env) {
-  if (!catalog || catalog.schema !== "agentspine.catalog/v1" || typeof path !== "string") return false;
-  const localStateRoot = stateRoot(env);
-  const pathBelongsToState = isInside(localStateRoot, path);
-  const canonicalRoot = comparablePath(catalog.root);
-  const canonicalStateRoot = comparablePath(localStateRoot);
-  if (!pathBelongsToState && !isInside(canonicalRoot, comparablePath(path))) return true;
-  if (pathBelongsToState && !isInside(canonicalRoot, canonicalStateRoot)) return true;
-  return catalog.scanPolicy?.stateRoot === "excluded"
-    && isUserHomeRoot(canonicalRoot, env)
-    && isInside(canonicalRoot, canonicalStateRoot)
-    && pathBelongsToState;
-}
-
-export function projectId(root) {
-  return createHash("sha256").update(root).digest("hex").slice(0, 20);
-}
-
-export async function projectStateDir(root) {
-  const target = join(stateRoot(), "projects", projectId(root));
-  await mkdir(target, { recursive: true, mode: 0o700 });
-  return target;
-}
+import { createHash } from "node:crypto";
+import { realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { lstat, mkdir, realpath } from "node:fs/promises";
+
+export async function canonicalPath(input = process.cwd()) {
+  return realpath(resolve(input));
+}
+
+export async function findProjectRoot(input = process.cwd()) {
+  if (process.env.AGENTSPINE_ROOT) return canonicalPath(process.env.AGENTSPINE_ROOT);
+  let cursor = await canonicalPath(input);
+  while (true) {
+    try {
+      await lstat(join(cursor, ".git"));
+      return cursor;
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    const parent = dirname(cursor);
+    if (parent === cursor) return canonicalPath(input);
+    cursor = parent;
+  }
+}
+
+export function isInside(parent, child, pathApi = { relative, isAbsolute, sep }) {
+  const value = pathApi.relative(parent, child);
+  return value === "" || (!pathApi.isAbsolute(value) && !value.startsWith(`..${pathApi.sep}`) && value !== "..");
+}
+
+export function ancestorsBetween(root, cwd) {
+  const result = [];
+  let cursor = resolve(cwd);
+  while (isInside(root, cursor)) {
+    result.push(cursor);
+    if (cursor === root) break;
+    const next = dirname(cursor);
+    if (next === cursor) break;
+    cursor = next;
+  }
+  return result.reverse();
+}
+
+export function stateRoot(env = process.env) {
+  if (env.AGENTSPINE_STATE_DIR) return resolve(env.AGENTSPINE_STATE_DIR);
+  if (process.platform === "win32") {
+    return join(env.LOCALAPPDATA || env.APPDATA || homedir(), "AgentSpine");
+  }
+  return join(env.XDG_STATE_HOME || join(homedir(), ".local", "state"), "agentspine");
+}
+
+export function comparablePath(value) {
+  let cursor = resolve(value);
+  const missing = [];
+  let canonical = cursor;
+  while (true) {
+    try {
+      canonical = realpathSync.native(cursor);
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT") break;
+      const parent = dirname(cursor);
+      if (parent === cursor) break;
+      missing.unshift(basename(cursor));
+      cursor = parent;
+    }
+  }
+  canonical = join(canonical, ...missing);
+  return canonical.replace(/[\\/]+$/, "");
+}
+
+function samePath(left, right) {
+  const normalize = comparablePath;
+  const a = normalize(left);
+  const b = normalize(right);
+  return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+}
+
+export function isUserHomeRoot(root, env = process.env) {
+  const candidates = [homedir(), env.HOME, env.USERPROFILE,
+    env.HOMEDRIVE && env.HOMEPATH ? `${env.HOMEDRIVE}${env.HOMEPATH}` : null]
+    .filter((value) => typeof value === "string" && value && isAbsolute(value));
+  return candidates.some((candidate) => samePath(root, candidate));
+}
+
+export function statePathIsScanExcluded(catalog, path, env = process.env) {
+  if (!catalog || catalog.schema !== "agentspine.catalog/v1" || typeof path !== "string") return false;
+  const localStateRoot = stateRoot(env);
+  const pathBelongsToState = isInside(localStateRoot, path);
+  const canonicalRoot = comparablePath(catalog.root);
+  const canonicalStateRoot = comparablePath(localStateRoot);
+  if (!pathBelongsToState && !isInside(canonicalRoot, comparablePath(path))) return true;
+  if (pathBelongsToState && !isInside(canonicalRoot, canonicalStateRoot)) return true;
+  return catalog.scanPolicy?.stateRoot === "excluded"
+    && isUserHomeRoot(canonicalRoot, env)
+    && isInside(canonicalRoot, canonicalStateRoot)
+    && pathBelongsToState;
+}
+
+export function projectId(root) {
+  return createHash("sha256").update(root).digest("hex").slice(0, 20);
+}
+
+export async function projectStateDir(root) {
+  const target = join(stateRoot(), "projects", projectId(root));
+  await mkdir(target, { recursive: true, mode: 0o700 });
+  return target;
+}