blun-king-cli 9.1.562 → 9.1.564

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

@@ -0,0 +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;
+      });
+    }
+  }
+}

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

@@ -6,6 +6,7 @@ import { isFileLockContention, replaceFileWithRetry } from "./filesystem-retry.j
 import { loadCoordination } from "./coordination.js";
 import { loadGraph } from "./graph.js";
 import { projectStateDir } from "./paths.js";
+import { isInaccessibleScanError } from "./source-roots.js";
 
 const POLICY_SCHEMA = "agentspine.execution-policy/v1";
 const JOB_SCHEMA = "agentspine.selfstarter/v1";
@@ -149,16 +150,39 @@ async function pathsFor(root, providedCatalog = null) {
 
 async function collectWorkspaceFiles(root) {
   const files = [];
+  const skippedInaccessibleEntries = [];
   let totalBytes = 0;
   async function walk(directory) {
-    const stream = await opendir(directory);
+    let stream;
+    try {
+      stream = await opendir(directory);
+    } catch (error) {
+      if (!isInaccessibleScanError(error)) throw error;
+      skippedInaccessibleEntries.push({
+        relativePath: relative(root, directory).split(sep).join("/") || ".",
+        code: error.code,
+        kind: "directory"
+      });
+      return;
+    }
     const entries = [];
     for await (const entry of stream) entries.push(entry);
     entries.sort((a, b) => a.name.localeCompare(b.name));
     for (const entry of entries) {
       if (EXCLUDED_NAMES.has(entry.name)) continue;
       const path = join(directory, entry.name);
-      const metadata = await lstat(path);
+      let metadata;
+      try {
+        metadata = await lstat(path);
+      } catch (error) {
+        if (!isInaccessibleScanError(error)) throw error;
+        skippedInaccessibleEntries.push({
+          relativePath: relative(root, path).split(sep).join("/"),
+          code: error.code,
+          kind: "entry"
+        });
+        continue;
+      }
       if (metadata.isSymbolicLink()) throw new Error(`workspace fingerprint rejects symbolic link: ${relative(root, path)}`);
       if (metadata.isDirectory()) await walk(path);
       else if (metadata.isFile()) {
@@ -171,18 +195,38 @@ async function collectWorkspaceFiles(root) {
     }
   }
   await walk(root);
-  return files;
+  return { files, skippedInaccessibleEntries };
 }
 
 export async function workspaceFingerprint(inputRoot = process.cwd()) {
   const root = resolve(inputRoot);
-  const files = await collectWorkspaceFiles(root);
+  const { files, skippedInaccessibleEntries } = await collectWorkspaceFiles(root);
   const hash = createHash("sha256");
+  for (const skipped of skippedInaccessibleEntries) {
+    hash.update("inaccessible\0").update(skipped.kind).update("\0")
+      .update(skipped.relativePath).update("\0").update(skipped.code).update("\0");
+  }
   for (const file of files) {
     hash.update(file.relativePath).update("\0").update(String(file.size)).update("\0");
     hash.update(await readFile(file.path)).update("\0");
   }
-  return { digest: hash.digest("hex"), files: files.length, bytes: files.reduce((sum, file) => sum + file.size, 0) };
+  return {
+    digest: hash.digest("hex"), files: files.length,
+    bytes: files.reduce((sum, file) => sum + file.size, 0),
+    skippedInaccessibleEntries: skippedInaccessibleEntries.length,
+    skippedInaccessibleDetails: skippedInaccessibleEntries
+  };
+}
+
+function incompleteWorkspaceScan(skipped) {
+  const first = skipped[0];
+  const error = new Error(`workspace scan skipped ${skipped.length} inaccessible path${skipped.length === 1 ? "" : "s"}: ${first.relativePath}`);
+  error.code = "AGENTSPINE_SCAN_INCOMPLETE";
+  error.path = first.relativePath;
+  error.syscall = first.kind;
+  error.agentSpineScan = true;
+  error.skipped = skipped;
+  return error;
 }
 
 function knownActor(graph, id) {
@@ -649,6 +693,9 @@ export async function authorizeJobEffect({
   const deliveryId = stableId(toolUseId, "toolUseId");
   const at = timestamp(now, "now");
   const fingerprint = await workspaceFingerprint(root);
+  if (fingerprint.skippedInaccessibleDetails.length) {
+    throw incompleteWorkspaceScan(fingerprint.skippedInaccessibleDetails);
+  }
   return lockedStates(root, ({ policy, state, coordination, paths }) => {
     const job = state.jobs.find((item) => item.id === scope.jobId);
     if (!job) throw new Error("unknown self-starter job");

package/agent-spine-plugin/src/lib/source-roots.js

@@ -20,6 +20,10 @@ const SOURCE_RESOLUTION_MS = 2000;
 const SAFE_NAME = /^[A-Za-z0-9._-]{1,128}$/;
 const SKIP_EXTRA_DIRS = new Set([".git", ".hg", ".svn", ".claude", ".codex", "node_modules", "vendor", "dist", "build", "coverage"]);
 
+export function isInaccessibleScanError(error) {
+  return error?.code === "EACCES" || error?.code === "EPERM";
+}
+
 function digest(value) { return createHash("sha256").update(value).digest("hex"); }
 function registryPath(env = process.env) { return join(stateRoot(env), "source-roots.json"); }
 function emptyRegistry() { return { schema: SOURCE_REGISTRY_SCHEMA, revision: 0, bindings: [], history: [] }; }
@@ -202,32 +206,41 @@ async function containsEmbeddedHostProfile(directory) {
 async function boundedMarkdownTree(directory, prefix, host, scope, precedenceStart, deadline, {
   projectBoundary = false,
   maxFiles = MAX_RULE_FILES,
-  maxDirectoryEntries = MAX_DIRECTORY_ENTRIES
+  maxDirectoryEntries = MAX_DIRECTORY_ENTRIES,
+  skippedInaccessibleDirectories = []
 } = {}) {
   const root = await existingDirectory(directory);
   if (!root) return [];
   const output = [];
   let visitedEntries = 0;
   async function walk(current) {
-    if (Date.now() > deadline) throw new Error(`host-native source resolution exceeded ${SOURCE_RESOLUTION_MS} ms`);
-    if (projectBoundary && current !== root
-      && (await containsProjectMarker(current) || await containsEmbeddedHostProfile(current))) return;
-    const entries = [];
-    for await (const entry of await opendir(current)) {
-      visitedEntries += 1;
-      if (visitedEntries > maxDirectoryEntries) throw new Error(`host-native source tree exceeds ${maxDirectoryEntries} entries`);
-      entries.push(entry);
-    }
-    entries.sort((a, b) => a.name.localeCompare(b.name));
-    for (const entry of entries) {
-      if (output.length >= maxFiles) throw new Error(`host-native rule tree exceeds ${maxFiles} files`);
-      if (entry.isSymbolicLink()) continue;
-      const path = join(current, entry.name);
-      if (entry.isDirectory() && !entry.name.startsWith(".") && !skippedExtraDirectory(entry.name)) await walk(path);
-      else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-        output.push({ path, id: `${prefix}/${relative(root, path).replaceAll("\\", "/")}`, host, scope,
-          binding: "host-native-rule-tree", precedence: precedenceStart + output.length });
+    try {
+      if (Date.now() > deadline) throw new Error(`host-native source resolution exceeded ${SOURCE_RESOLUTION_MS} ms`);
+      if (projectBoundary && current !== root
+        && (await containsProjectMarker(current) || await containsEmbeddedHostProfile(current))) return;
+      const entries = [];
+      for await (const entry of await opendir(current)) {
+        visitedEntries += 1;
+        if (visitedEntries > maxDirectoryEntries) throw new Error(`host-native source tree exceeds ${maxDirectoryEntries} entries`);
+        entries.push(entry);
       }
+      entries.sort((a, b) => a.name.localeCompare(b.name));
+      for (const entry of entries) {
+        if (output.length >= maxFiles) throw new Error(`host-native rule tree exceeds ${maxFiles} files`);
+        if (entry.isSymbolicLink()) continue;
+        const path = join(current, entry.name);
+        if (entry.isDirectory() && !entry.name.startsWith(".") && !skippedExtraDirectory(entry.name)) await walk(path);
+        else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+          output.push({ path, id: `${prefix}/${relative(root, path).replaceAll("\\", "/")}`, host, scope,
+            binding: "host-native-rule-tree", precedence: precedenceStart + output.length });
+        }
+      }
+    } catch (error) {
+      if (!isInaccessibleScanError(error)) throw error;
+      skippedInaccessibleDirectories.push({
+        relativePath: relative(root, current).replaceAll("\\", "/") || ".",
+        code: error.code
+      });
     }
   }
   await walk(root);
@@ -434,9 +447,11 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
   const knownHomeRoots = await homeRoots(env);
   const skippedHomeTree = knownHomeRoots.some((root) => samePath(root, projectRoot));
   const skippedFallbackHomeTree = skippedHomeTree && rootResolution === "cwd-fallback";
+  const skippedInaccessibleDirectories = [];
   if (!skippedHomeTree) {
     sources.push(...await boundedMarkdownTree(projectRoot, "agentspine:project", host, "project", 3000, deadline,
-      { projectBoundary: true, maxFiles: MAX_PROJECT_FILES, maxDirectoryEntries: MAX_PROJECT_DIRECTORY_ENTRIES }));
+      { projectBoundary: true, maxFiles: MAX_PROJECT_FILES, maxDirectoryEntries: MAX_PROJECT_DIRECTORY_ENTRIES,
+        skippedInaccessibleDirectories }));
   }
   const nativeNames = new Set(host === "codex"
     ? ["AGENTS.override.md", "AGENTS.md", ...(hostDetails.fallbackNames || [])]
@@ -459,6 +474,7 @@ export async function resolveHostSourceCatalog({ host, cwd = process.cwd(), inpu
     personalContinuityLoaded: documents.some((item) => item.sourceScope === "user") || Boolean(activeUserState),
     broadHomeScan: false, projectTreeScan: skippedFallbackHomeTree ? "skipped-unmarked-home"
       : skippedHomeTree ? "skipped-home-root" : "bounded",
+    skippedInaccessibleDirectories,
     rootResolution, registryRevision: registry.revision,
     ...(host === "claude" ? {
       memoryBound: Boolean(hostDetails.memoryRoot),

package/agent-spine-plugin/src/version.js

@@ -1 +1 @@
-export const VERSION = "0.11.4";
+export const VERSION = "0.49.0";

package/blun.mjs

@@ -342898,6 +342898,7 @@ function detectedUiLocale() {
 const SOURCE_LOCALE = "en";
 const PLACEHOLDER_PATTERN = /\{([A-Za-z][A-Za-z0-9_]*)\}/g;
 const catalogs = {};
+const missingLocalizedUiTextWarnings = /* @__PURE__ */ new Set();
 let currentUiLocale = SOURCE_LOCALE;
 function registerUiCatalogFragment(fragment) {
 	for (const [locale, copy] of Object.entries(fragment)) {
@@ -342928,7 +342929,13 @@ function uiTextFor(locale, key, params = {}) {
 	const sourceTemplate = catalogs[SOURCE_LOCALE]?.[key];
 	if (sourceTemplate === void 0) throw new Error(`Missing English UI source text for key "${key}".`);
 	const localizedTemplate = catalogs[locale]?.[key];
-	if (locale !== SOURCE_LOCALE && isUiLocaleAvailable(locale) && localizedTemplate === void 0) throw new Error(`Missing UI text for key "${key}" in released locale "${locale}".`);
+	if (locale !== SOURCE_LOCALE && isUiLocaleAvailable(locale) && localizedTemplate === void 0) {
+		const warningKey = `${locale}:${key}`;
+		if (!missingLocalizedUiTextWarnings.has(warningKey)) {
+			missingLocalizedUiTextWarnings.add(warningKey);
+			log?.warn("Missing localized UI text; using English fallback", { locale, key });
+		}
+	}
 	const template = localizedTemplate ?? sourceTemplate;
 	validateCatalogPlaceholders(key, sourceTemplate, template);
 	return interpolate(key, template, params);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.562",
+  "version": "9.1.564",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {