toolcraft 0.0.23 → 0.0.25

package/node_modules/@poe-code/config-mutations/dist/execution/apply-mutation.js

@@ -1,3 +1,4 @@
+import path from "node:path";
 import { renderTemplate } from "@poe-code/design-system";
 import { getConfigFormat, detectFormat } from "../formats/index.js";
 import { resolvePath } from "./path-utils.js";
@@ -15,9 +16,78 @@ function createInvalidDocumentBackupPath(targetPath) {
     const ext = targetPath.includes(".") ? targetPath.split(".").pop() : "bak";
     return `${targetPath}.invalid-${createTimestamp()}.${ext}`;
 }
-async function backupInvalidDocument(fs, targetPath, content) {
-    const backupPath = createInvalidDocumentBackupPath(targetPath);
-    await fs.writeFile(backupPath, content, { encoding: "utf8" });
+async function backupInvalidDocument(context, targetPath, content) {
+    const baseBackupPath = createInvalidDocumentBackupPath(targetPath);
+    let attempt = 0;
+    while (true) {
+        const backupPath = attempt === 0 ? baseBackupPath : `${baseBackupPath}-${attempt}`;
+        await assertRegularWriteTarget(context, backupPath);
+        try {
+            await context.fs.writeFile(backupPath, content, { encoding: "utf8", flag: "wx" });
+            return;
+        }
+        catch (error) {
+            if (!isAlreadyExists(error)) {
+                throw error;
+            }
+            attempt += 1;
+        }
+    }
+}
+function isAlreadyExists(error) {
+    return Boolean(error && typeof error === "object" && "code" in error && error.code === "EEXIST");
+}
+async function assertRegularWriteTarget(context, targetPath) {
+    // Symlinks inside the managed home directory are untrusted: an attacker could
+    // plant one to redirect a credential/config write outside it. Symlinks at or
+    // above home are legitimate system links (e.g. /tmp -> /private/tmp on macOS,
+    // /var -> /private/var) and must not block writes, so bound the walk at home.
+    const boundary = path.dirname(path.resolve(context.homeDir));
+    let currentPath = path.resolve(targetPath);
+    while (currentPath !== boundary) {
+        try {
+            if ((await context.fs.lstat(currentPath)).isSymbolicLink()) {
+                throw new Error(`Refusing mutation write through symbolic link: ${currentPath}`);
+            }
+        }
+        catch (error) {
+            if (!isNotFound(error)) {
+                throw error;
+            }
+        }
+        const parentPath = path.dirname(currentPath);
+        if (parentPath === currentPath) {
+            return;
+        }
+        currentPath = parentPath;
+    }
+}
+async function writeAtomically(context, targetPath, content) {
+    await assertRegularWriteTarget(context, targetPath);
+    let attempt = 0;
+    while (true) {
+        const tempPath = `${targetPath}.mutation-tmp-${attempt}`;
+        try {
+            await context.fs.writeFile(tempPath, content, { encoding: "utf8", flag: "wx" });
+            await context.fs.rename(tempPath, targetPath);
+            return;
+        }
+        catch (error) {
+            if (isAlreadyExists(error)) {
+                attempt += 1;
+                continue;
+            }
+            try {
+                await context.fs.unlink(tempPath);
+            }
+            catch (cleanupError) {
+                if (!isNotFound(cleanupError)) {
+                    void cleanupError;
+                }
+            }
+            throw error;
+        }
+    }
 }
 function describeMutation(kind, targetPath) {
     const displayPath = targetPath ?? "target";
@@ -28,6 +98,8 @@ function describeMutation(kind, targetPath) {
             return `Remove directory ${displayPath}`;
         case "backup":
             return `Backup ${displayPath}`;
+        case "restoreBackup":
+            return `Restore ${displayPath}`;
         case "templateWrite":
             return `Write ${displayPath}`;
         case "chmod":
@@ -91,6 +163,8 @@ export async function applyMutation(mutation, context, options) {
             return applyChmod(mutation, context, options);
         case "backup":
             return applyBackup(mutation, context, options);
+        case "restoreBackup":
+            return applyRestoreBackup(mutation, context, options);
         case "configMerge":
             return applyConfigMerge(mutation, context, options);
         case "configPrune":
@@ -190,6 +264,9 @@ async function applyRemoveFile(mutation, context, options) {
         const content = await context.fs.readFile(targetPath, "utf8");
         const trimmed = content.trim();
         // Check whenContentMatches guard
+        if (mutation.whenContentMatches) {
+            mutation.whenContentMatches.lastIndex = 0;
+        }
         if (mutation.whenContentMatches && !mutation.whenContentMatches.test(trimmed)) {
             return {
                 outcome: { changed: false, effect: "none", detail: "noop" },
@@ -270,22 +347,122 @@ async function applyBackup(mutation, context, options) {
         label: mutation.label ?? describeMutation(mutation.kind, targetPath),
         targetPath
     };
+    if (mutation.once && (await findLatestGeneratedBackup(context.fs, targetPath)) !== null) {
+        return {
+            outcome: { changed: false, effect: "none", detail: "noop" },
+            details
+        };
+    }
     const content = await readFileIfExists(context.fs, targetPath);
-    if (content === null) {
+    if (content === null && !mutation.once) {
         return {
             outcome: { changed: false, effect: "none", detail: "noop" },
             details
         };
     }
     if (!context.dryRun) {
-        const backupPath = `${targetPath}.backup-${createTimestamp()}`;
-        await context.fs.writeFile(backupPath, content, { encoding: "utf8" });
+        const baseBackupPath = `${targetPath}.backup-${createTimestamp()}${content === null ? ".missing" : ""}`;
+        let attempt = 0;
+        while (true) {
+            const backupPath = attempt === 0 ? baseBackupPath : `${baseBackupPath}-${attempt}`;
+            try {
+                await assertRegularWriteTarget(context, backupPath);
+                await context.fs.writeFile(backupPath, content ?? "", { encoding: "utf8", flag: "wx" });
+                break;
+            }
+            catch (error) {
+                if (!isAlreadyExists(error)) {
+                    throw error;
+                }
+                attempt += 1;
+            }
+        }
     }
     return {
         outcome: { changed: true, effect: "copy", detail: "backup" },
         details
     };
 }
+async function applyRestoreBackup(mutation, context, options) {
+    const rawPath = resolveValue(mutation.target, options);
+    const targetPath = resolvePath(rawPath, context.homeDir, context.pathMapper);
+    const details = {
+        kind: mutation.kind,
+        label: mutation.label ?? describeMutation(mutation.kind, targetPath),
+        targetPath
+    };
+    const backup = await findLatestGeneratedBackup(context.fs, targetPath);
+    if (backup === null) {
+        return { outcome: { changed: false, effect: "none", detail: "noop" }, details };
+    }
+    if (!context.dryRun) {
+        await assertRegularWriteTarget(context, backup.path);
+        if (backup.originallyMissing) {
+            try {
+                await context.fs.unlink(targetPath);
+            }
+            catch (error) {
+                if (!isNotFound(error)) {
+                    throw error;
+                }
+            }
+        }
+        else {
+            const content = await context.fs.readFile(backup.path, "utf8");
+            await writeAtomically(context, targetPath, content);
+        }
+        await context.fs.unlink(backup.path);
+    }
+    return { outcome: { changed: true, effect: "copy", detail: "restore" }, details };
+}
+async function findLatestGeneratedBackup(fs, targetPath) {
+    const separatorIndex = targetPath.lastIndexOf("/");
+    const directoryPath = separatorIndex <= 0 ? "/" : targetPath.slice(0, separatorIndex);
+    const targetName = targetPath.slice(separatorIndex + 1);
+    let entries;
+    try {
+        entries = await fs.readdir(directoryPath);
+    }
+    catch (error) {
+        if (isNotFound(error)) {
+            return null;
+        }
+        throw error;
+    }
+    const backupName = entries
+        .filter((entry) => isGeneratedBackupName(entry, targetName))
+        .sort()
+        .at(-1);
+    return backupName === undefined
+        ? null
+        : {
+            path: `${directoryPath}/${backupName}`,
+            originallyMissing: backupName.endsWith(".missing")
+        };
+}
+function isGeneratedBackupName(entry, targetName) {
+    const prefix = `${targetName}.backup-`;
+    if (!entry.startsWith(prefix)) {
+        return false;
+    }
+    const suffix = entry.slice(prefix.length);
+    const timestamp = suffix.slice(0, 24);
+    if (timestamp.length !== 24 || timestamp[4] !== "-" || timestamp[7] !== "-" || timestamp[10] !== "T" || timestamp[13] !== "-" || timestamp[16] !== "-" || timestamp[19] !== "-" || timestamp[23] !== "Z") {
+        return false;
+    }
+    const parsedTimestamp = `${timestamp.slice(0, 13)}:${timestamp.slice(14, 16)}:${timestamp.slice(17, 19)}.${timestamp.slice(20)}`;
+    if (Number.isNaN(Date.parse(parsedTimestamp))) {
+        return false;
+    }
+    const collisionSuffix = suffix.slice(24);
+    if (collisionSuffix.length === 0) {
+        return true;
+    }
+    if (collisionSuffix === ".missing") {
+        return true;
+    }
+    return collisionSuffix[0] === "-" && collisionSuffix.slice(1).length > 0 && [...collisionSuffix.slice(1)].every((character) => character >= "0" && character <= "9");
+}
 // ============================================================================
 // Config Mutation Handlers
 // ============================================================================
@@ -309,8 +486,8 @@ async function applyConfigMerge(mutation, context, options) {
     }
     catch {
         // Invalid file - backup and start fresh
-        if (rawContent !== null) {
-            await backupInvalidDocument(context.fs, targetPath, rawContent);
+        if (rawContent !== null && !context.dryRun) {
+            await backupInvalidDocument(context, targetPath, rawContent);
         }
         current = {};
     }
@@ -326,7 +503,7 @@ async function applyConfigMerge(mutation, context, options) {
     const serialized = format.serialize(merged);
     const changed = serialized !== rawContent;
     if (changed && !context.dryRun) {
-        await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+        await writeAtomically(context, targetPath, serialized);
     }
     return {
         outcome: {
@@ -395,7 +572,7 @@ async function applyConfigPrune(mutation, context, options) {
     }
     const serialized = format.serialize(result);
     if (!context.dryRun) {
-        await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+        await writeAtomically(context, targetPath, serialized);
     }
     return {
         outcome: { changed: true, effect: "write", detail: "update" },
@@ -421,8 +598,8 @@ async function applyConfigTransform(mutation, context, options) {
         current = rawContent === null ? {} : format.parse(rawContent);
     }
     catch {
-        if (rawContent !== null) {
-            await backupInvalidDocument(context.fs, targetPath, rawContent);
+        if (rawContent !== null && !context.dryRun) {
+            await backupInvalidDocument(context, targetPath, rawContent);
         }
         current = {};
     }
@@ -451,7 +628,7 @@ async function applyConfigTransform(mutation, context, options) {
     }
     const serialized = format.serialize(transformed);
     if (!context.dryRun) {
-        await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+        await writeAtomically(context, targetPath, serialized);
     }
     return {
         outcome: {
@@ -482,15 +659,16 @@ async function applyTemplateWrite(mutation, context, options) {
         ? resolveValue(mutation.context, options)
         : {};
     const rendered = renderTemplate(template, templateContext);
-    const existed = await pathExists(context.fs, targetPath);
-    if (!context.dryRun) {
-        await context.fs.writeFile(targetPath, rendered, { encoding: "utf8" });
+    const current = await readFileIfExists(context.fs, targetPath);
+    const changed = current !== rendered;
+    if (changed && !context.dryRun) {
+        await writeAtomically(context, targetPath, rendered);
     }
     return {
         outcome: {
-            changed: true,
-            effect: "write",
-            detail: existed ? "update" : "create"
+            changed,
+            effect: changed ? "write" : "none",
+            detail: changed ? (current === null ? "create" : "update") : "noop"
         },
         details
     };
@@ -529,8 +707,8 @@ async function applyTemplateMerge(mutation, context, options, formatName) {
         current = rawContent === null ? {} : format.parse(rawContent);
     }
     catch {
-        if (rawContent !== null) {
-            await backupInvalidDocument(context.fs, targetPath, rawContent);
+        if (rawContent !== null && !context.dryRun) {
+            await backupInvalidDocument(context, targetPath, rawContent);
         }
         current = {};
     }
@@ -539,7 +717,7 @@ async function applyTemplateMerge(mutation, context, options, formatName) {
     const serialized = format.serialize(merged);
     const changed = serialized !== rawContent;
     if (changed && !context.dryRun) {
-        await context.fs.writeFile(targetPath, serialized, { encoding: "utf8" });
+        await writeAtomically(context, targetPath, serialized);
     }
     return {
         outcome: {

package/node_modules/@poe-code/config-mutations/dist/execution/path-utils.js

@@ -45,8 +45,14 @@ export function validateHomePath(targetPath) {
 export function resolvePath(rawPath, homeDir, pathMapper) {
     validateHomePath(rawPath);
     const expanded = expandHome(rawPath, homeDir);
+    const canonicalHome = path.resolve(homeDir);
+    const canonicalExpanded = path.resolve(expanded);
+    const relative = path.relative(canonicalHome, canonicalExpanded);
+    if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) {
+        throw new Error(`Target path resolves outside home directory: "${rawPath}"`);
+    }
     if (!pathMapper) {
-        return expanded;
+        return canonicalExpanded;
     }
     // Map the directory portion
     const rawDirectory = path.dirname(expanded);

package/node_modules/@poe-code/config-mutations/dist/formats/index.js

@@ -17,7 +17,7 @@ const extensionMap = {
  */
 export function getConfigFormat(pathOrFormat) {
     // Check if it's an explicit format name
-    if (pathOrFormat in formatRegistry) {
+    if (Object.prototype.hasOwnProperty.call(formatRegistry, pathOrFormat)) {
         return formatRegistry[pathOrFormat];
     }
     // Try to detect from extension

package/node_modules/@poe-code/config-mutations/dist/formats/json.js

@@ -1,4 +1,5 @@
 import * as jsonc from "jsonc-parser";
+import { cloneConfigObject, hasConfigEntry, setConfigEntry } from "./object.js";
 function isConfigObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -27,31 +28,31 @@ function parse(content) {
     if (!isConfigObject(parsed)) {
         throw new Error("Expected JSON object.");
     }
-    return parsed;
+    return cloneConfigObject(parsed);
 }
 function serialize(obj) {
     return `${JSON.stringify(obj, null, 2)}\n`;
 }
 function merge(base, patch) {
-    const result = { ...base };
+    const result = cloneConfigObject(base);
     for (const [key, value] of Object.entries(patch)) {
         if (value === undefined) {
             continue;
         }
         const existing = result[key];
         if (isConfigObject(existing) && isConfigObject(value)) {
-            result[key] = merge(existing, value);
+            setConfigEntry(result, key, merge(existing, value));
             continue;
         }
-        result[key] = value;
+        setConfigEntry(result, key, value);
     }
     return result;
 }
 function prune(obj, shape) {
     let changed = false;
-    const result = { ...obj };
+    const result = cloneConfigObject(obj);
     for (const [key, pattern] of Object.entries(shape)) {
-        if (!(key in result)) {
+        if (!hasConfigEntry(result, key)) {
             continue;
         }
         const current = result[key];
@@ -71,10 +72,13 @@ function prune(obj, shape) {
                 delete result[key];
             }
             else {
-                result[key] = childResult;
+                setConfigEntry(result, key, childResult);
             }
             continue;
         }
+        if (isConfigObject(pattern) && Object.keys(pattern).length > 0) {
+            continue;
+        }
         delete result[key];
         changed = true;
     }

package/node_modules/@poe-code/config-mutations/dist/formats/object.d.ts

@@ -0,0 +1,4 @@
+import type { ConfigObject, ConfigValue } from "../types.js";
+export declare function cloneConfigObject(value: ConfigObject): ConfigObject;
+export declare function setConfigEntry(target: ConfigObject, key: string, value: ConfigValue): void;
+export declare function hasConfigEntry(target: ConfigObject, key: string): boolean;

package/node_modules/@poe-code/config-mutations/dist/formats/object.js

@@ -0,0 +1,27 @@
+export function cloneConfigObject(value) {
+    const result = {};
+    for (const [key, entry] of Object.entries(value)) {
+        setConfigEntry(result, key, cloneConfigValue(entry));
+    }
+    return result;
+}
+export function setConfigEntry(target, key, value) {
+    Object.defineProperty(target, key, {
+        configurable: true,
+        enumerable: true,
+        writable: true,
+        value
+    });
+}
+export function hasConfigEntry(target, key) {
+    return Object.prototype.hasOwnProperty.call(target, key);
+}
+function cloneConfigValue(value) {
+    if (Array.isArray(value)) {
+        return value.map((entry) => cloneConfigValue(entry));
+    }
+    if (value && typeof value === "object" && !(value instanceof Date)) {
+        return cloneConfigObject(value);
+    }
+    return value;
+}

package/node_modules/@poe-code/config-mutations/dist/formats/toml.js

@@ -1,4 +1,5 @@
 import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { cloneConfigObject, hasConfigEntry, setConfigEntry } from "./object.js";
 function isConfigObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -10,32 +11,32 @@ function parse(content) {
     if (!isConfigObject(parsed)) {
         throw new Error("Expected TOML document to be a table.");
     }
-    return parsed;
+    return cloneConfigObject(parsed);
 }
 function serialize(obj) {
     const serialized = stringifyToml(obj);
     return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
 }
 function merge(base, patch) {
-    const result = { ...base };
+    const result = cloneConfigObject(base);
     for (const [key, value] of Object.entries(patch)) {
         if (value === undefined) {
             continue;
         }
         const existing = result[key];
         if (isConfigObject(existing) && isConfigObject(value)) {
-            result[key] = merge(existing, value);
+            setConfigEntry(result, key, merge(existing, value));
             continue;
         }
-        result[key] = value;
+        setConfigEntry(result, key, value);
     }
     return result;
 }
 function prune(obj, shape) {
     let changed = false;
-    const result = { ...obj };
+    const result = cloneConfigObject(obj);
     for (const [key, pattern] of Object.entries(shape)) {
-        if (!(key in result)) {
+        if (!hasConfigEntry(result, key)) {
             continue;
         }
         const current = result[key];
@@ -55,12 +56,14 @@ function prune(obj, shape) {
                 delete result[key];
             }
             else {
-                result[key] = childResult;
+                setConfigEntry(result, key, childResult);
             }
             continue;
         }
-        delete result[key];
-        changed = true;
+        if (!isConfigObject(pattern) || Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+        }
     }
     return { changed, result };
 }

package/node_modules/@poe-code/config-mutations/dist/formats/yaml.js

@@ -1,4 +1,5 @@
 import { parse as parseYaml, stringify as stringifyYaml } from "yaml";
+import { cloneConfigObject, hasConfigEntry, setConfigEntry } from "./object.js";
 function isConfigObject(value) {
     return typeof value === "object" && value !== null && !Array.isArray(value);
 }
@@ -13,32 +14,32 @@ function parse(content) {
     if (!isConfigObject(parsed)) {
         throw new Error("Expected YAML object.");
     }
-    return parsed;
+    return cloneConfigObject(parsed);
 }
 function serialize(obj) {
     const serialized = stringifyYaml(obj);
     return serialized.endsWith("\n") ? serialized : `${serialized}\n`;
 }
 function merge(base, patch) {
-    const result = { ...base };
+    const result = cloneConfigObject(base);
     for (const [key, value] of Object.entries(patch)) {
         if (value === undefined) {
             continue;
         }
         const existing = result[key];
         if (isConfigObject(existing) && isConfigObject(value)) {
-            result[key] = merge(existing, value);
+            setConfigEntry(result, key, merge(existing, value));
             continue;
         }
-        result[key] = value;
+        setConfigEntry(result, key, value);
     }
     return result;
 }
 function prune(obj, shape) {
     let changed = false;
-    const result = { ...obj };
+    const result = cloneConfigObject(obj);
     for (const [key, pattern] of Object.entries(shape)) {
-        if (!(key in result)) {
+        if (!hasConfigEntry(result, key)) {
             continue;
         }
         const current = result[key];
@@ -56,12 +57,14 @@ function prune(obj, shape) {
                 delete result[key];
             }
             else {
-                result[key] = childResult;
+                setConfigEntry(result, key, childResult);
             }
             continue;
         }
-        delete result[key];
-        changed = true;
+        if (!isConfigObject(pattern) || Object.keys(pattern).length === 0) {
+            delete result[key];
+            changed = true;
+        }
     }
     return { changed, result };
 }

package/node_modules/@poe-code/config-mutations/dist/mutations/file-mutation.d.ts

@@ -1,4 +1,4 @@
-import type { EnsureDirectoryMutation, RemoveDirectoryMutation, RemoveFileMutation, ChmodMutation, BackupMutation, ValueResolver } from "../types.js";
+import type { EnsureDirectoryMutation, RemoveDirectoryMutation, RemoveFileMutation, ChmodMutation, BackupMutation, RestoreBackupMutation, ValueResolver } from "../types.js";
 export interface EnsureDirectoryOptions {
     /** Directory path (must start with ~) */
     path: ValueResolver<string>;
@@ -34,6 +34,14 @@ export interface ChmodOptions {
 export interface BackupOptions {
     /** Target file path to backup (must start with ~) */
     target: ValueResolver<string>;
+    /** Keep the first baseline only, including an originally missing target. */
+    once?: boolean;
+    /** Optional human-readable label for logging */
+    label?: string;
+}
+export interface RestoreBackupOptions {
+    /** Target file path whose latest generated backup should be restored. */
+    target: ValueResolver<string>;
     /** Optional human-readable label for logging */
     label?: string;
 }
@@ -42,11 +50,13 @@ declare function remove(options: RemoveOptions): RemoveFileMutation;
 declare function removeDirectory(options: RemoveDirectoryOptions): RemoveDirectoryMutation;
 declare function chmod(options: ChmodOptions): ChmodMutation;
 declare function backup(options: BackupOptions): BackupMutation;
+declare function restoreBackup(options: RestoreBackupOptions): RestoreBackupMutation;
 export declare const fileMutation: {
     ensureDirectory: typeof ensureDirectory;
     remove: typeof remove;
     removeDirectory: typeof removeDirectory;
     chmod: typeof chmod;
     backup: typeof backup;
+    restoreBackup: typeof restoreBackup;
 };
 export {};

package/node_modules/@poe-code/config-mutations/dist/mutations/file-mutation.js

@@ -34,6 +34,14 @@ function backup(options) {
     return {
         kind: "backup",
         target: options.target,
+        once: options.once,
+        label: options.label
+    };
+}
+function restoreBackup(options) {
+    return {
+        kind: "restoreBackup",
+        target: options.target,
         label: options.label
     };
 }
@@ -42,5 +50,6 @@ export const fileMutation = {
     remove,
     removeDirectory,
     chmod,
-    backup
+    backup,
+    restoreBackup
 };

package/node_modules/@poe-code/config-mutations/dist/testing/mock-fs.js

@@ -46,8 +46,12 @@ export function createMockFs(initialFiles, homeDir = DEFAULT_HOME_DIR) {
             return Buffer.from(content, "utf8");
         },
         async writeFile(filePath, content, options) {
-            void options; // TypeScript satisfaction
             const absolutePath = expandPath(filePath, homeDir);
+            if (options?.flag === "wx" && absolutePath in files) {
+                const error = new Error(`EEXIST: file already exists, open '${absolutePath}'`);
+                error.code = "EEXIST";
+                throw error;
+            }
             // Ensure parent directory exists
             const parentDir = path.dirname(absolutePath);
             if (!directories.has(parentDir)) {
@@ -90,6 +94,17 @@ export function createMockFs(initialFiles, homeDir = DEFAULT_HOME_DIR) {
             }
             delete files[absolutePath];
         },
+        async rename(oldPath, newPath) {
+            const absoluteOldPath = expandPath(oldPath, homeDir);
+            const absoluteNewPath = expandPath(newPath, homeDir);
+            if (!(absoluteOldPath in files)) {
+                const error = new Error(`ENOENT: no such file or directory, rename '${absoluteOldPath}'`);
+                error.code = "ENOENT";
+                throw error;
+            }
+            files[absoluteNewPath] = files[absoluteOldPath];
+            delete files[absoluteOldPath];
+        },
         async stat(filePath) {
             const absolutePath = expandPath(filePath, homeDir);
             if (absolutePath in files) {
@@ -102,6 +117,15 @@ export function createMockFs(initialFiles, homeDir = DEFAULT_HOME_DIR) {
             error.code = "ENOENT";
             throw error;
         },
+        async lstat(filePath) {
+            const absolutePath = expandPath(filePath, homeDir);
+            if (absolutePath in files || directories.has(absolutePath)) {
+                return { isSymbolicLink: () => false };
+            }
+            const error = new Error(`ENOENT: no such file or directory, lstat '${absolutePath}'`);
+            error.code = "ENOENT";
+            throw error;
+        },
         async readdir(dirPath) {
             const absolutePath = expandPath(dirPath, homeDir);
             if (absolutePath in files) {