@lousy-agents/lint 5.15.7 → 5.16.0

package/dist/index.js

@@ -566,7 +566,7 @@ module.exports = webpackEmptyAsyncContext;
 
 
 },
-2749(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+6179(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -884,16 +884,24 @@ function createBoundedReadStream(opened, maxBytes) {
 }
 
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/file-identity.js
+
 function isZero(value) {
     return value === 0 || value === 0n;
 }
+function sameStatValue(left, right) {
+    return typeof left === typeof right ? left === right : BigInt(left) === BigInt(right);
+}
+function sha256Hex(data, encoding) {
+    const buffer = typeof data === "string" ? Buffer.from(data, encoding ?? "utf8") : data;
+    return (0,external_node_crypto_.createHash)("sha256").update(buffer).digest("hex");
+}
 function file_identity_sameFileIdentity(left, right, platform = process.platform) {
-    if (left.ino !== right.ino) {
+    if (!sameStatValue(left.ino, right.ino)) {
         return false;
     }
     // On Windows, path-based stat calls can report dev=0 while fd-based stat
     // reports a real volume serial; treat either-side dev=0 as "unknown device".
-    if (left.dev === right.dev) {
+    if (sameStatValue(left.dev, right.dev)) {
         return true;
     }
     return platform === "win32" && (isZero(left.dev) || isZero(right.dev));
@@ -2287,6 +2295,377 @@ async function runPinnedPathHelper(params) {
     }
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/sidecar-lock.js
+
+
+
+
+const GLOBAL_STATE_KEY = Symbol.for("fsSafe.sidecarLockManagers");
+function getGlobalManagers() {
+    const globalWithState = globalThis;
+    if (!globalWithState[GLOBAL_STATE_KEY]) {
+        globalWithState[GLOBAL_STATE_KEY] = new Map();
+    }
+    return globalWithState[GLOBAL_STATE_KEY];
+}
+function resolveManagerState(key) {
+    const managers = getGlobalManagers();
+    let state = managers.get(key);
+    if (!state) {
+        state = { cleanupRegistered: false, held: new Map() };
+        managers.set(key, state);
+    }
+    return state;
+}
+async function readLockSnapshot(lockPath) {
+    try {
+        const stat = await promises_.lstat(lockPath);
+        const raw = await promises_.readFile(lockPath, "utf8");
+        try {
+            const parsed = JSON.parse(raw);
+            const payload = parsed && typeof parsed === "object" && !Array.isArray(parsed)
+                ? parsed
+                : null;
+            return { raw, payload, stat };
+        }
+        catch {
+            return { raw, payload: null, stat };
+        }
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return null;
+        }
+        throw err;
+    }
+}
+function snapshotMatches(current, observed) {
+    if (observed.stat && current.stat && !file_identity_sameFileIdentity(observed.stat, current.stat)) {
+        return false;
+    }
+    if (observed.raw !== undefined) {
+        return current.raw === observed.raw;
+    }
+    return observed.stat !== undefined && current.stat !== undefined;
+}
+async function removeLockIfUnchanged(lockPath, observed) {
+    const current = await readLockSnapshot(lockPath);
+    if (!current || !observed) {
+        return false;
+    }
+    if (!snapshotMatches(current, observed)) {
+        // The lock changed after we decided it was stale. Leave the fresh holder's
+        // file alone; deleting by path here would break mutual exclusion.
+        return false;
+    }
+    await promises_.rm(lockPath, { force: true }).catch(() => undefined);
+    return true;
+}
+async function lockSnapshotStillPresent(lockPath, observed) {
+    const current = await readLockSnapshot(lockPath);
+    return !!current && !!observed && snapshotMatches(current, observed);
+}
+async function removeStaleLockIfAllowed(params) {
+    if (!params.shouldRemoveStaleLock) {
+        return "not-approved";
+    }
+    if (params.snapshot.raw === undefined) {
+        return "not-approved";
+    }
+    if (!(await params.shouldRemoveStaleLock({
+        lockPath: params.lockPath,
+        normalizedTargetPath: params.normalizedTargetPath,
+        raw: params.snapshot.raw,
+        payload: params.snapshot.payload,
+    }))) {
+        return "not-approved";
+    }
+    const current = await readLockSnapshot(params.lockPath);
+    if (!current || !snapshotMatches(current, params.snapshot)) {
+        return "changed";
+    }
+    try {
+        await promises_.rm(params.lockPath, { force: true });
+    }
+    catch (err) {
+        if (err.code === "ENOENT") {
+            return "changed";
+        }
+        return "not-approved";
+    }
+    return "removed";
+}
+function snapshotMatchesSync(lockPath, observed) {
+    try {
+        const stat = external_node_fs_.lstatSync(lockPath);
+        if (observed.stat && !file_identity_sameFileIdentity(observed.stat, stat)) {
+            return false;
+        }
+        return observed.raw === undefined || external_node_fs_.readFileSync(lockPath, "utf8") === observed.raw;
+    }
+    catch {
+        return false;
+    }
+}
+async function resolveNormalizedTargetPath(targetPath) {
+    const resolved = external_node_path_.resolve(targetPath);
+    const dir = external_node_path_.dirname(resolved);
+    await promises_.mkdir(dir, { recursive: true });
+    try {
+        return external_node_path_.join(await promises_.realpath(dir), external_node_path_.basename(resolved));
+    }
+    catch {
+        return resolved;
+    }
+}
+function computeDelayMs(retry, attempt) {
+    const minTimeout = retry.minTimeout ?? 50;
+    const maxTimeout = retry.maxTimeout ?? 1000;
+    const factor = retry.factor ?? 1;
+    const base = Math.min(maxTimeout, Math.max(minTimeout, minTimeout * factor ** attempt));
+    const jitter = retry.randomize ? 1 + Math.random() : 1;
+    return Math.min(maxTimeout, Math.round(base * jitter));
+}
+async function defaultShouldReclaim(params) {
+    const createdAt = typeof params.payload?.createdAt === "string" ? params.payload.createdAt : "";
+    const createdAtMs = Date.parse(createdAt);
+    if (Number.isFinite(createdAtMs) && params.nowMs - createdAtMs > params.staleMs) {
+        return true;
+    }
+    try {
+        const stat = await promises_.stat(params.lockPath);
+        return params.nowMs - stat.mtimeMs > params.staleMs;
+    }
+    catch {
+        return true;
+    }
+}
+function releaseAllLocksSync(state) {
+    for (const [normalizedTargetPath, held] of state.held) {
+        void held.handle.close().catch(() => undefined);
+        try {
+            if (snapshotMatchesSync(held.lockPath, held.snapshot)) {
+                external_node_fs_.rmSync(held.lockPath, { force: true });
+            }
+        }
+        catch {
+            // Best-effort process-exit cleanup.
+        }
+        state.held.delete(normalizedTargetPath);
+    }
+}
+async function releaseHeldLock(state, normalizedTargetPath, held, opts = {}) {
+    const current = state.held.get(normalizedTargetPath);
+    if (current !== held) {
+        return false;
+    }
+    if (opts.force) {
+        held.count = 0;
+    }
+    else {
+        held.count -= 1;
+        if (held.count > 0) {
+            return false;
+        }
+    }
+    if (held.releasePromise) {
+        await held.releasePromise.catch(() => undefined);
+        return true;
+    }
+    state.held.delete(normalizedTargetPath);
+    held.releasePromise = (async () => {
+        await held.handle.close().catch(() => undefined);
+        await removeLockIfUnchanged(held.lockPath, held.snapshot);
+    })();
+    try {
+        await held.releasePromise;
+        return true;
+    }
+    finally {
+        held.releasePromise = undefined;
+    }
+}
+function createSidecarLockManager(key) {
+    const state = resolveManagerState(key);
+    function ensureExitCleanupRegistered() {
+        if (state.cleanupRegistered) {
+            return;
+        }
+        state.cleanupRegistered = true;
+        process.on("exit", () => releaseAllLocksSync(state));
+    }
+    async function acquire(options) {
+        ensureExitCleanupRegistered();
+        const normalizedTargetPath = await resolveNormalizedTargetPath(options.targetPath);
+        const lockPath = options.lockPath ?? `${normalizedTargetPath}.lock`;
+        const held = state.held.get(normalizedTargetPath);
+        if (held && options.allowReentrant) {
+            held.count += 1;
+            const release = () => releaseHeldLock(state, normalizedTargetPath, held).then(() => undefined);
+            return {
+                lockPath,
+                normalizedTargetPath,
+                release,
+                [Symbol.asyncDispose]: release,
+            };
+        }
+        const startedAt = Date.now();
+        const retry = options.retry ?? {};
+        const maxRetries = options.timeoutMs === Number.POSITIVE_INFINITY ? undefined : retry.retries;
+        let attempt = 0;
+        while (true) {
+            let handle = null;
+            try {
+                handle = await promises_.open(lockPath, "wx");
+                const payload = await options.payload();
+                const raw = `${JSON.stringify(payload, null, 2)}\n`;
+                await handle.writeFile(raw, "utf8");
+                const snapshot = { raw, payload, stat: await handle.stat() };
+                const createdHeld = {
+                    count: 1,
+                    handle,
+                    lockPath,
+                    snapshot,
+                    acquiredAt: Date.now(),
+                    metadata: options.metadata ?? {},
+                };
+                state.held.set(normalizedTargetPath, createdHeld);
+                const release = () => releaseHeldLock(state, normalizedTargetPath, createdHeld).then(() => undefined);
+                return {
+                    lockPath,
+                    normalizedTargetPath,
+                    release,
+                    [Symbol.asyncDispose]: release,
+                };
+            }
+            catch (err) {
+                if (handle) {
+                    const failedSnapshot = { payload: null };
+                    try {
+                        failedSnapshot.stat = await handle.stat();
+                    }
+                    catch {
+                        // Best-effort cleanup of a failed exclusive create.
+                    }
+                    const current = state.held.get(normalizedTargetPath);
+                    if (current?.handle === handle) {
+                        state.held.delete(normalizedTargetPath);
+                    }
+                    // If payload serialization/write fails, the file may be empty or
+                    // partial JSON, so remove while our exclusive handle is still open.
+                    await promises_.rm(lockPath, { force: true }).catch(() => undefined);
+                    await handle.close().catch(() => undefined);
+                    // Windows can refuse removing an open file; retry after close but
+                    // only if the path still points at the file identity we created.
+                    await removeLockIfUnchanged(lockPath, failedSnapshot);
+                }
+                if (err.code !== "EEXIST") {
+                    throw err;
+                }
+                const nowMs = Date.now();
+                const snapshot = await readLockSnapshot(lockPath);
+                if (!snapshot) {
+                    continue;
+                }
+                const shouldReclaim = options.shouldReclaim ?? defaultShouldReclaim;
+                if (await shouldReclaim({
+                    lockPath,
+                    normalizedTargetPath,
+                    payload: snapshot?.payload ?? null,
+                    staleMs: options.staleMs,
+                    nowMs,
+                    heldByThisProcess: state.held.has(normalizedTargetPath),
+                })) {
+                    if (!(await lockSnapshotStillPresent(lockPath, snapshot))) {
+                        continue;
+                    }
+                    const staleRecovery = options.staleRecovery ?? "fail-closed";
+                    if (staleRecovery === "remove-if-unchanged") {
+                        const removal = await removeStaleLockIfAllowed({
+                            lockPath,
+                            normalizedTargetPath,
+                            snapshot,
+                            shouldRemoveStaleLock: options.shouldRemoveStaleLock,
+                        });
+                        if (removal === "removed" || removal === "changed") {
+                            continue;
+                        }
+                    }
+                    throw Object.assign(new Error(`file lock stale for ${normalizedTargetPath}`), {
+                        code: "file_lock_stale",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                const elapsed = Date.now() - startedAt;
+                if ((options.timeoutMs !== undefined &&
+                    options.timeoutMs !== Number.POSITIVE_INFINITY &&
+                    elapsed >= options.timeoutMs) ||
+                    (maxRetries !== undefined && attempt >= maxRetries)) {
+                    throw Object.assign(new Error(`file lock timeout for ${normalizedTargetPath}`), {
+                        code: "file_lock_timeout",
+                        lockPath,
+                        normalizedTargetPath,
+                    });
+                }
+                const remaining = options.timeoutMs === undefined || options.timeoutMs === Number.POSITIVE_INFINITY
+                    ? Number.POSITIVE_INFINITY
+                    : Math.max(0, options.timeoutMs - elapsed);
+                const delay = Math.min(computeDelayMs(retry, attempt), remaining);
+                attempt += 1;
+                await new Promise((resolve) => setTimeout(resolve, delay));
+            }
+        }
+    }
+    async function withLock(options, fn) {
+        const lock = await acquire(options);
+        try {
+            return await fn();
+        }
+        finally {
+            await lock.release();
+        }
+    }
+    async function drain() {
+        for (const [normalizedTargetPath, held] of Array.from(state.held.entries())) {
+            await releaseHeldLock(state, normalizedTargetPath, held, { force: true }).catch(() => undefined);
+        }
+    }
+    function reset() {
+        releaseAllLocksSync(state);
+    }
+    function heldEntries() {
+        return Array.from(state.held.entries()).map(([normalizedTargetPath, held]) => ({
+            normalizedTargetPath,
+            lockPath: held.lockPath,
+            acquiredAt: held.acquiredAt,
+            metadata: held.metadata,
+            forceRelease: () => releaseHeldLock(state, normalizedTargetPath, held, { force: true }),
+        }));
+    }
+    return { acquire, withLock, drain, reset, heldEntries };
+}
+async function withSidecarLock(targetPath, options, fn) {
+    const manager = createSidecarLockManager(options.managerKey ?? `fs-safe.sidecar-lock:${targetPath}`);
+    const { managerKey: _managerKey, ...acquireOptions } = options;
+    return await manager.withLock({ ...acquireOptions, targetPath }, fn);
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
+let test_hooks_fsSafeTestHooks;
+function allowFsSafeTestHooks() {
+    return  false || process.env.VITEST === "true";
+}
+function getFsSafeTestHooks() {
+    return test_hooks_fsSafeTestHooks;
+}
+function __setFsSafeTestHooksForTest(hooks) {
+    if (hooks && !allowFsSafeTestHooks()) {
+        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
+    }
+    test_hooks_fsSafeTestHooks = hooks;
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/pinned-write.js
 
 
@@ -2300,6 +2679,8 @@ async function runPinnedPathHelper(params) {
 
 
 
+
+
 function byteLength(input, encoding) {
     return typeof input === "string"
         ? Buffer.byteLength(input, encoding ?? "utf8")
@@ -2357,6 +2738,12 @@ async function runPinnedWriteHelper(params) {
     validatePinnedOperationPayload({
         relativeParentPath: params.relativeParentPath,
     });
+    // The Python helper deliberately enforces the strict post-rename inode
+    // contract. The explicit compatibility policy therefore uses the guarded
+    // Node fallback, where content verification can replace that one check.
+    if (params.onRenameIdentityMismatch === "verify-content") {
+        return await runPinnedWriteFallback(params);
+    }
     if (getFsSafePythonConfig().mode === "off") {
         return await runPinnedWriteFallback(params);
     }
@@ -2371,8 +2758,11 @@ async function runPinnedWriteHelper(params) {
             throw error;
         }
     }
+    const input = params.input.kind === "stream"
+        ? { kind: "buffer", data: Buffer.from(await inputToBase64(params.input, params.maxBytes), "base64") }
+        : params.input;
     const payload = {
-        base64: await inputToBase64(params.input, params.maxBytes),
+        base64: await inputToBase64(input, params.maxBytes),
         basename: params.basename,
         maxBytes: params.maxBytes ?? -1,
         mkdir: params.mkdir,
@@ -2390,11 +2780,32 @@ async function runPinnedWriteHelper(params) {
     }
     catch (error) {
         if (canFallbackFromPythonError(error)) {
-            return await runPinnedWriteFallback(params);
+            return await runPinnedWriteFallback({ ...params, input });
         }
         throw error;
     }
 }
+async function runPinnedWriteWithRenamePolicy(params) {
+    const { targetPath, renameIdentity, ...writeParams } = params;
+    if (renameIdentity !== "verify-content-with-lock") {
+        return await runPinnedWriteHelper(writeParams);
+    }
+    const relativeTargetPath = writeParams.relativeParentPath
+        ? `${writeParams.relativeParentPath}/${writeParams.basename}`
+        : writeParams.basename;
+    const lockPath = external_node_path_.join(writeParams.rootPath, `.fs-safe-write-${sha256Hex(relativeTargetPath)}.lock`);
+    return await withSidecarLock(writeParams.rootPath, {
+        managerKey: `fs-safe.write:${targetPath}`,
+        lockPath,
+        staleMs: 30_000,
+        timeoutMs: 5_000,
+        payload: () => ({ pid: process.pid, createdAt: new Date().toISOString() }),
+        retry: { retries: 5, minTimeout: 100, maxTimeout: 2_000, factor: 2 },
+    }, async () => await runPinnedWriteHelper({
+        ...writeParams,
+        onRenameIdentityMismatch: "verify-content",
+    }));
+}
 async function runPinnedCopyHelper(params) {
     assertSafeBasename(params.basename);
     validatePinnedOperationPayload({
@@ -2450,7 +2861,10 @@ async function runPinnedWriteFallback(params) {
             else {
                 await writeStreamToHandle(params.input.stream, handle, params.maxBytes);
             }
+            await handle.sync();
             const stat = await handle.stat();
+            await handle.close().catch(() => undefined);
+            await syncDirectoryBestEffort(parentPath);
             created = false;
             return { dev: stat.dev, ino: stat.ino };
         }
@@ -2498,11 +2912,49 @@ async function runPinnedWriteFallback(params) {
         await withAsyncDirectoryGuards([parentGuard], async () => {
             await promises_.rename(tempPath, targetPath);
             renamed = true;
+            await getFsSafeTestHooks()?.afterPinnedWriteFallbackRename?.(targetPath);
             await syncDirectoryBestEffort(parentPath);
             targetStat = await promises_.lstat(targetPath);
-            if (targetStat.isSymbolicLink() || !file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+            if (targetStat.isSymbolicLink()) {
                 throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
             }
+            if (!file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
+                // On filesystems like rclone FUSE, rename(2) can give the destination a
+                // different inode from the source temp fd even with zero concurrency. The
+                // caller must ensure mutual exclusion before passing "verify-content";
+                // fall back to a content hash for this rename-boundary check only.
+                if (params.onRenameIdentityMismatch !== "verify-content") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                if (params.input.kind !== "buffer") {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                const expectedHash = sha256Hex(params.input.data, params.input.encoding);
+                const readFlags = external_node_fs_.constants.O_RDONLY |
+                    (process.platform !== "win32" && "O_NOFOLLOW" in external_node_fs_.constants
+                        ? external_node_fs_.constants.O_NOFOLLOW
+                        : 0);
+                const readHandle = await promises_.open(targetPath, readFlags);
+                let actualHash;
+                let readHandleStat;
+                try {
+                    // Capture fd-based identity before reading — this is stable across all
+                    // subsequent lookups (on FUSE and locally), unlike the lstat-based
+                    // targetStat that triggered this fallback.
+                    readHandleStat = await readHandle.stat();
+                    actualHash = sha256Hex(await readHandle.readFile());
+                }
+                finally {
+                    await readHandle.close().catch(() => undefined);
+                }
+                if (actualHash !== expectedHash) {
+                    throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
+                }
+                // Replace the unreliable lstat-based targetStat with the fd-based stat so
+                // the returned identity is consistent with what subsequent verifications
+                // (e.g. verifyAtomicWriteResult) will obtain by opening the same file.
+                targetStat = readHandleStat;
+            }
         });
     }
     catch (error) {
@@ -3598,21 +4050,6 @@ function normalizePinnedPathError(error) {
     });
 }
 
-;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/test-hooks.js
-let test_hooks_fsSafeTestHooks;
-function allowFsSafeTestHooks() {
-    return  false || process.env.VITEST === "true";
-}
-function getFsSafeTestHooks() {
-    return test_hooks_fsSafeTestHooks;
-}
-function __setFsSafeTestHooksForTest(hooks) {
-    if (hooks && !allowFsSafeTestHooks()) {
-        throw new Error("__setFsSafeTestHooksForTest is only available in tests");
-    }
-    test_hooks_fsSafeTestHooks = hooks;
-}
-
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/json-stringify.js
 function stringifyJsonDocument(value, replacer, space) {
     const text = JSON.stringify(value, replacer, space);
@@ -3948,6 +4385,7 @@ class RootHandle {
             data,
             mkdir: this.defaults.mkdir,
             mode: this.defaults.mode,
+            renameIdentity: this.defaults.renameIdentity,
             ...options,
             denyMutations: mergeDenyMutationPolicies(this.defaults.denyMutations, options.denyMutations),
         });
@@ -4382,21 +4820,23 @@ async function writeFileInRoot(root, params) {
 async function commitPinnedWriteInRoot(root, pinned, params) {
     let identity;
     try {
-        identity = await runPinnedWriteHelper({
+        identity = await runPinnedWriteWithRenamePolicy({
             rootPath: pinned.rootReal,
             relativeParentPath: pinned.relativeParentPath,
             basename: pinned.basename,
+            targetPath: pinned.targetPath,
+            renameIdentity: params.renameIdentity,
             mkdir: params.mkdir !== false,
             mode: params.mode ?? pinned.mode,
             overwrite: params.overwrite,
-            input: {
-                kind: "buffer",
-                data: params.data,
-                encoding: params.encoding,
-            },
+            input: { kind: "buffer", data: params.data, encoding: params.encoding },
         });
     }
     catch (error) {
+        const errorCode = error?.code;
+        if (errorCode === "file_lock_stale" || errorCode === "file_lock_timeout") {
+            throw error;
+        }
         if (params.overwrite === false && isAlreadyExistsError(error)) {
             throw new errors_FsSafeError("already-exists", "file already exists", {
                 cause: error instanceof Error ? error : undefined,
@@ -46550,7 +46990,7 @@ if (installedChunkData !== 0) { // 0 means "already installed".'
 // module factories are used so entry inlining is disabled
 // startup
 // Load entry module and return exports
-var __webpack_exports__ = __webpack_require__(2749);
+var __webpack_exports__ = __webpack_require__(6179);
 var __webpack_exports__DEFAULT_LINT_RULES = __webpack_exports__.Kd;
 var __webpack_exports__LintValidationError = __webpack_exports__.F5;
 var __webpack_exports__createFormatter = __webpack_exports__.xi;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@lousy-agents/lint",
-    "version": "5.15.7",
+    "version": "5.16.0",
     "description": "Programmatic lint API for validating AI coding assistant configurations — skills, agents, hooks, and instructions",
     "type": "module",
     "repository": {