@lousy-agents/lint 5.15.4 → 5.15.6

package/dist/index.js

@@ -566,7 +566,7 @@ module.exports = webpackEmptyAsyncContext;
 
 
 },
-9884(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
+2749(__unused_rspack_module, __webpack_exports__, __webpack_require__) {
 
 // EXPORTS
 __webpack_require__.d(__webpack_exports__, {
@@ -978,6 +978,7 @@ function hasNonEmptyString(value) {
 
 
 
+
 const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
 const SYMLINK_OPEN_CODES = new Set(["ELOOP", "EINVAL", "ENOTSUP"]);
 const POSIX_SEPARATOR_CHAR_CODE = 0x2f;
@@ -1177,6 +1178,29 @@ function directory_guard_createNearestExistingSyncDirectoryGuard(rootReal, targe
     return directory_guard_createSyncDirectoryGuard(root);
 }
 
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/fsync.js
+
+
+async function syncDirectoryBestEffort(dirPath) {
+    if (process.platform === "win32") {
+        return;
+    }
+    let handle;
+    try {
+        const flags = external_node_fs_.constants.O_RDONLY |
+            ("O_DIRECTORY" in external_node_fs_.constants ? external_node_fs_.constants.O_DIRECTORY : 0) |
+            ("O_NOFOLLOW" in external_node_fs_.constants ? external_node_fs_.constants.O_NOFOLLOW : 0);
+        handle = await promises_.open(dirPath, flags);
+        await handle.sync();
+    }
+    catch {
+        // Some filesystems reject directory handles; keep the write usable there.
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/guarded-mkdir.js
 
 
@@ -2275,6 +2299,7 @@ async function runPinnedPathHelper(params) {
 
 
 
+
 function byteLength(input, encoding) {
     return typeof input === "string"
         ? Buffer.byteLength(input, encoding ?? "utf8")
@@ -2467,11 +2492,13 @@ async function runPinnedWriteFallback(params) {
             throw new errors_FsSafeError("path-mismatch", "fallback temp path changed during write");
         }
         const expectedTempStat = tempStat;
+        await handle.sync();
         await handle.close().catch(() => undefined);
         handle = undefined;
         await withAsyncDirectoryGuards([parentGuard], async () => {
             await promises_.rename(tempPath, targetPath);
             renamed = true;
+            await syncDirectoryBestEffort(parentPath);
             targetStat = await promises_.lstat(targetPath);
             if (targetStat.isSymbolicLink() || !file_identity_sameFileIdentity(targetStat, expectedTempStat)) {
                 throw new errors_FsSafeError("path-mismatch", "fallback target changed during write");
@@ -3145,6 +3172,197 @@ function path_policy_shortPath(value) {
     return value;
 }
 
+// EXTERNAL MODULE: external "node:url"
+var external_node_url_ = __webpack_require__(3136);
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/local-file-access.js
+
+
+
+const ENCODED_FILE_URL_SEPARATOR_RE = /%(?:2f|5c)/i;
+function isLocalFileUrlHost(hostname) {
+    const normalized = normalizeLowercaseStringOrEmpty(hostname);
+    return normalized === "" || normalized === "localhost";
+}
+function hasEncodedFileUrlSeparator(pathname) {
+    return ENCODED_FILE_URL_SEPARATOR_RE.test(pathname);
+}
+function isWindowsNetworkPath(filePath, platform = process.platform) {
+    if (platform !== "win32") {
+        return false;
+    }
+    const normalized = filePath.replace(/\//g, "\\");
+    return normalized.startsWith("\\\\?\\UNC\\") || normalized.startsWith("\\\\");
+}
+function isWindowsDriveLetterPath(filePath, platform = process.platform) {
+    return platform === "win32" && /^[A-Za-z]:[\\/]/.test(filePath);
+}
+function assertNoWindowsNetworkPath(filePath, label = "Path") {
+    if (isWindowsNetworkPath(filePath)) {
+        throw new Error(`${label} cannot use Windows network paths: ${filePath}`);
+    }
+}
+function safeFileURLToPath(fileUrl) {
+    let parsed;
+    try {
+        parsed = new external_node_url_.URL(fileUrl);
+    }
+    catch {
+        throw new Error(`Invalid file:// URL: ${fileUrl}`);
+    }
+    if (parsed.protocol !== "file:") {
+        throw new Error(`Invalid file:// URL: ${fileUrl}`);
+    }
+    if (!isLocalFileUrlHost(parsed.hostname)) {
+        throw new Error(`file:// URLs with remote hosts are not allowed: ${fileUrl}`);
+    }
+    if (hasEncodedFileUrlSeparator(parsed.pathname)) {
+        throw new Error(`file:// URLs cannot encode path separators: ${fileUrl}`);
+    }
+    const filePath = (0,external_node_url_.fileURLToPath)(parsed);
+    assertNoWindowsNetworkPath(filePath, "Local file URL");
+    return filePath;
+}
+function trySafeFileURLToPath(fileUrl) {
+    try {
+        return safeFileURLToPath(fileUrl);
+    }
+    catch {
+        return undefined;
+    }
+}
+function basenameFromMediaSource(source) {
+    if (!source) {
+        return undefined;
+    }
+    if (source.startsWith("file://")) {
+        const filePath = trySafeFileURLToPath(source);
+        return filePath ? path.basename(filePath) || undefined : undefined;
+    }
+    if (/^https?:\/\//i.test(source)) {
+        try {
+            return path.basename(new URL(source).pathname) || undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return path.basename(source) || undefined;
+}
+
+;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/device-path.js
+
+
+
+const POSIX_BLOCKED_DEVICE_PATHS = new Set([
+    "/dev/zero",
+    "/dev/random",
+    "/dev/urandom",
+    "/dev/full",
+    "/dev/stdin",
+    "/dev/stdout",
+    "/dev/stderr",
+    "/dev/tty",
+    "/dev/console",
+]);
+const WINDOWS_RESERVED_DEVICE_NAMES = new Set([
+    "CON",
+    "PRN",
+    "AUX",
+    "NUL",
+    "CLOCK$",
+    "CONIN$",
+    "CONOUT$",
+    "COM1",
+    "COM2",
+    "COM3",
+    "COM4",
+    "COM5",
+    "COM6",
+    "COM7",
+    "COM8",
+    "COM9",
+    "COM¹",
+    "COM²",
+    "COM³",
+    "LPT1",
+    "LPT2",
+    "LPT3",
+    "LPT4",
+    "LPT5",
+    "LPT6",
+    "LPT7",
+    "LPT8",
+    "LPT9",
+    "LPT¹",
+    "LPT²",
+    "LPT³",
+]);
+function candidateReadPaths(filePath) {
+    if (!filePath.startsWith("file://")) {
+        return [filePath];
+    }
+    const parsed = trySafeFileURLToPath(filePath);
+    return parsed === undefined ? [filePath] : [filePath, parsed];
+}
+function normalizePosixPath(filePath, cwd) {
+    if (external_node_path_.posix.isAbsolute(filePath)) {
+        return external_node_path_.posix.normalize(filePath);
+    }
+    const base = cwd && external_node_path_.posix.isAbsolute(cwd) ? cwd : process.cwd();
+    return external_node_path_.posix.resolve(base, filePath);
+}
+function matchPosixDeviceReadPath(filePath, cwd) {
+    const normalized = normalizePosixPath(filePath, cwd);
+    if (POSIX_BLOCKED_DEVICE_PATHS.has(normalized)) {
+        return { path: normalized, reason: "posix-device" };
+    }
+    if (normalized === "/dev/fd" || normalized.startsWith("/dev/fd/")) {
+        return { path: normalized, reason: "posix-fd" };
+    }
+    if (/^\/proc\/(?:self|thread-self|\d+)\/fd(?:\/|$)/.test(normalized)) {
+        return { path: normalized, reason: "posix-fd" };
+    }
+    return undefined;
+}
+function normalizeWindowsDeviceBaseName(filePath) {
+    const normalized = filePath.replace(/\//g, "\\").replace(/[\\]+$/g, "");
+    const lastSegment = normalized.split("\\").filter(Boolean).at(-1) ?? normalized;
+    const withoutStream = lastSegment.split(":")[0] ?? lastSegment;
+    const withoutTrailingIgnoredChars = withoutStream.replace(/[ .]+$/g, "");
+    return (withoutTrailingIgnoredChars.split(".")[0] ?? withoutTrailingIgnoredChars).toUpperCase();
+}
+function matchWindowsDeviceReadPath(filePath) {
+    const normalized = filePath.replace(/\//g, "\\");
+    if (/^\\\\\.\\/.test(normalized) || /^\\\\\?\\GLOBALROOT\\Device\\/i.test(normalized)) {
+        return { path: normalized, reason: "windows-device" };
+    }
+    const baseName = normalizeWindowsDeviceBaseName(filePath);
+    if (WINDOWS_RESERVED_DEVICE_NAMES.has(baseName)) {
+        return { path: normalized, reason: "windows-device" };
+    }
+    return undefined;
+}
+function matchUnsafeDeviceReadPath(filePath, options = {}) {
+    const platform = options.platform ?? process.platform;
+    for (const candidate of candidateReadPaths(filePath)) {
+        const match = platform === "win32"
+            ? matchWindowsDeviceReadPath(candidate)
+            : matchPosixDeviceReadPath(candidate, options.cwd);
+        if (match) {
+            return match;
+        }
+    }
+    return undefined;
+}
+function isUnsafeDeviceReadPath(filePath, options) {
+    return matchUnsafeDeviceReadPath(filePath, options) !== undefined;
+}
+function assertNoUnsafeDeviceReadPath(filePath, options) {
+    if (matchUnsafeDeviceReadPath(filePath, options)) {
+        throw new errors_FsSafeError("device-path", `file reads from unsafe device paths are not allowed: ${filePath}`);
+    }
+}
+
 ;// CONCATENATED MODULE: ../../node_modules/@openclaw/fs-safe/dist/read-opened-file.js
 
 async function read_opened_file_readOpenedFileSafely(params) {
@@ -3496,6 +3714,7 @@ async function serializePathWrite(key, run) {
 
 
 
+
 
 
 function logWarn(message) {
@@ -3521,20 +3740,16 @@ const OPEN_APPEND_CREATE_FLAGS = external_node_fs_.constants.O_RDWR |
     external_node_fs_.constants.O_EXCL |
     (SUPPORTS_NOFOLLOW ? external_node_fs_.constants.O_NOFOLLOW : 0);
 const DEFAULT_ROOT_MAX_BYTES = 16 * 1024 * 1024;
-function closeHandleForDispose(handle) {
-    return handle.close().catch(() => undefined);
-}
 function openResult(params) {
     return {
         handle: params.handle,
         realPath: params.realPath,
         stat: params.stat,
-        [Symbol.asyncDispose]: async () => {
-            await closeHandleForDispose(params.handle);
-        },
+        [Symbol.asyncDispose]: () => params.handle.close().catch(() => undefined),
     };
 }
 async function openVerifiedLocalFile(filePath, options) {
+    assertNoUnsafeDeviceReadPath(filePath);
     const fsSafeTestHooks = getFsSafeTestHooks();
     // Reject directories before opening so we never surface EISDIR to callers (e.g. tool
     // results that get sent to messaging channels). See openclaw/openclaw#31186.
@@ -4059,9 +4274,7 @@ async function openWritableFileInRoot(root, params) {
             createdForWrite,
             realPath,
             stat,
-            [Symbol.asyncDispose]: async () => {
-                await closeHandleForDispose(handle);
-            },
+            [Symbol.asyncDispose]: () => handle.close().catch(() => undefined),
         };
     }
     catch (err) {
@@ -4098,10 +4311,15 @@ async function appendFileInRoot(root, params) {
         }
         if (typeof params.data === "string") {
             await target.handle.appendFile(`${prefix}${params.data}`, params.encoding ?? "utf8");
-            return;
         }
-        const payload = prefix.length > 0 ? Buffer.concat([Buffer.from(prefix, "utf8"), params.data]) : params.data;
-        await target.handle.appendFile(payload);
+        else {
+            const payload = prefix.length > 0 ? Buffer.concat([Buffer.from(prefix, "utf8"), params.data]) : params.data;
+            await target.handle.appendFile(payload);
+        }
+        await target.handle.sync();
+        if (target.createdForWrite) {
+            await syncDirectoryBestEffort(external_node_path_.dirname(target.realPath));
+        }
     }
     finally {
         await target.handle.close().catch(() => { });
@@ -4158,42 +4376,45 @@ async function writeFileInRoot(root, params) {
     }
     const pinned = await resolvePinnedWriteTargetInRoot(root, params.relativePath, params.mode, params.denyMutations);
     await serializePathWrite(pinned.targetPath, async () => {
-        let identity;
-        try {
-            identity = await runPinnedWriteHelper({
-                rootPath: pinned.rootReal,
-                relativeParentPath: pinned.relativeParentPath,
-                basename: pinned.basename,
-                mkdir: params.mkdir !== false,
-                mode: params.mode ?? pinned.mode,
-                overwrite: params.overwrite,
-                input: {
-                    kind: "buffer",
-                    data: params.data,
-                    encoding: params.encoding,
-                },
-            });
-        }
-        catch (error) {
-            if (params.overwrite === false && isAlreadyExistsError(error)) {
-                throw new errors_FsSafeError("already-exists", "file already exists", {
-                    cause: error instanceof Error ? error : undefined,
-                });
-            }
-            throw normalizePinnedWriteError(error);
-        }
-        try {
-            await verifyAtomicWriteResult({
-                root,
-                targetPath: pinned.targetPath,
-                expectedIdentity: identity,
+        await commitPinnedWriteInRoot(root, pinned, params);
+    });
+}
+async function commitPinnedWriteInRoot(root, pinned, params) {
+    let identity;
+    try {
+        identity = await runPinnedWriteHelper({
+            rootPath: pinned.rootReal,
+            relativeParentPath: pinned.relativeParentPath,
+            basename: pinned.basename,
+            mkdir: params.mkdir !== false,
+            mode: params.mode ?? pinned.mode,
+            overwrite: params.overwrite,
+            input: {
+                kind: "buffer",
+                data: params.data,
+                encoding: params.encoding,
+            },
+        });
+    }
+    catch (error) {
+        if (params.overwrite === false && isAlreadyExistsError(error)) {
+            throw new errors_FsSafeError("already-exists", "file already exists", {
+                cause: error instanceof Error ? error : undefined,
             });
         }
-        catch (err) {
-            emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`);
-            throw err;
-        }
-    });
+        throw normalizePinnedWriteError(error);
+    }
+    try {
+        await verifyAtomicWriteResult({
+            root,
+            targetPath: pinned.targetPath,
+            expectedIdentity: identity,
+        });
+    }
+    catch (err) {
+        emitWriteBoundaryWarning(`post-write verification failed: ${String(err)}`);
+        throw err;
+    }
 }
 async function copyFileInRoot(root, params) {
     assertValidRootRelativePath(params.relativePath);
@@ -21965,8 +22186,6 @@ function isUrl(fileUrlOrPath) {
   )
 }
 
-// EXTERNAL MODULE: external "node:url"
-var external_node_url_ = __webpack_require__(3136);
 ;// CONCATENATED MODULE: ../../node_modules/vfile/lib/index.js
 /**
  * @import {Node, Point, Position} from 'unist'
@@ -25783,7 +26002,7 @@ const regexes_base64 = /^$|^(?:[0-9a-zA-Z+/]{4})*(?:(?:[0-9a-zA-Z+/]{2}==)|(?:[0
 const regexes_base64url = /^[A-Za-z0-9_-]*$/;
 // based on https://stackoverflow.com/questions/106179/regular-expression-to-match-dns-hostname-or-ip-address
 // export const hostname: RegExp = /^([a-zA-Z0-9-]+\.)*[a-zA-Z0-9-]+$/;
-const hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
+const regexes_hostname = /^(?=.{1,253}\.?$)[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[-0-9a-zA-Z]{0,61}[0-9a-zA-Z])?)*\.?$/;
 const domain = /^([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
 const httpProtocol = /^https?$/;
 // https://blog.stevenlevithan.com/archives/validate-phone-number#r4-3 (regex sans spaces)
@@ -46330,7 +46549,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__(9884);
+var __webpack_exports__ = __webpack_require__(2749);
 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.4",
+    "version": "5.15.6",
     "description": "Programmatic lint API for validating AI coding assistant configurations — skills, agents, hooks, and instructions",
     "type": "module",
     "repository": {