toolcraft 0.0.23 → 0.0.24

package/node_modules/@poe-code/task-list/dist/backends/markdown-dir.js

@@ -1,17 +1,15 @@
 import path from "node:path";
-import { acquireFileLock } from "@poe-code/file-lock";
 import { parseDocument, stringify } from "yaml";
 import taskSchema from "../schema/task.schema.json" with { type: "json" };
 import { eventsFromState, findEvent } from "../state-machine.js";
 import { resolveStateMachine } from "../state.js";
 import { AnchorNotFoundError, InvalidTransitionError, MalformedTaskError, OrderMismatchError, TaskAlreadyExistsError, TaskNotFoundError } from "../types.js";
-import { applyOrder, hasErrorCode, isRecord, sortStrings, statIfExists, validateTaskId, writeAtomically } from "./utils.js";
+import { applyOrder, hasErrorCode, isRecord, rejectSymbolicLinkComponents, sortStrings, statIfExists, validateTaskId, withFileLock, writeAtomically } from "./utils.js";
 const ARCHIVE_DIRECTORY_NAME = "archive";
 const MARKDOWN_EXTENSION = ".md";
 const TASK_KIND = "task";
 const TASK_VERSION = 1;
 const TASK_SCHEMA_ID = taskSchema.$id;
-const ORDER_LOCK_FILENAME = ".order.lock";
 const MIN_PREFIX_WIDTH = 2;
 const RESERVED_FRONTMATTER_KEYS = new Set([
     "$schema",
@@ -69,9 +67,6 @@ function isMarkdownFile(entryName) {
 function isHiddenEntry(entryName) {
     return entryName.startsWith(".");
 }
-function isLockFile(entryName) {
-    return entryName.endsWith(".lock");
-}
 function isValidTaskIdShape(id) {
     return (id.length > 0 &&
         !id.startsWith(".") &&
@@ -170,12 +165,20 @@ function assertValidTaskRecord(frontmatter, filePath, validStates) {
 function reservedFrontmatterKeys(mode) {
     return mode === "passthrough" ? PASSTHROUGH_RESERVED_FRONTMATTER_KEYS : RESERVED_FRONTMATTER_KEYS;
 }
+function setOwnValue(record, key, value) {
+    Object.defineProperty(record, key, {
+        value,
+        enumerable: true,
+        writable: true,
+        configurable: true
+    });
+}
 function metadataFromFrontmatter(frontmatter, mode) {
     const metadata = {};
     const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(frontmatter)) {
         if (!reservedKeys.has(key)) {
-            metadata[key] = value;
+            setOwnValue(metadata, key, value);
         }
     }
     return metadata;
@@ -207,6 +210,7 @@ async function readDirectoryNames(fs, directoryPath) {
     }
 }
 async function ensureRootPath(deps) {
+    await rejectSymbolicLinkComponents(deps.fs, deps.path);
     if (deps.create) {
         await deps.fs.mkdir(deps.path, { recursive: true });
         return;
@@ -214,6 +218,7 @@ async function ensureRootPath(deps) {
     await deps.fs.stat(deps.path);
 }
 async function readTaskFile(fs, list, id, filePath, validStates, initialState, mode) {
+    await rejectSymbolicLinkComponents(fs, filePath);
     const content = await fs.readFile(filePath, "utf8");
     const document = splitTaskDocument(content, filePath, mode);
     const frontmatter = mode === "passthrough" && document.frontmatter.trim().length === 0
@@ -245,7 +250,7 @@ async function readTaskFile(fs, list, id, filePath, validStates, initialState, m
 async function findActiveTaskFilename(fs, listDirectoryPath, id) {
     const entries = await readDirectoryNames(fs, listDirectoryPath);
     for (const entryName of entries) {
-        if (isHiddenEntry(entryName) || isLockFile(entryName))
+        if (isHiddenEntry(entryName))
             continue;
         const parsed = parseActiveFilename(entryName);
         if (parsed?.id === id) {
@@ -256,15 +261,19 @@ async function findActiveTaskFilename(fs, listDirectoryPath, id) {
 }
 async function findTaskLocation(fs, rootPath, layout, list, id) {
     const listDirectoryPath = listPath(rootPath, layout, list);
+    await rejectSymbolicLinkComponents(fs, listDirectoryPath);
     const activeName = await findActiveTaskFilename(fs, listDirectoryPath, id);
     if (activeName) {
         const activePath = path.join(listDirectoryPath, activeName);
+        await rejectSymbolicLinkComponents(fs, activePath);
         const activeStat = await statIfExists(fs, activePath);
         if (activeStat?.isFile()) {
             return { archived: false, path: activePath };
         }
     }
     const archivedPath = archivedTaskPath(rootPath, layout, list, id);
+    await rejectSymbolicLinkComponents(fs, archiveDirectoryPath(rootPath, layout, list));
+    await rejectSymbolicLinkComponents(fs, archivedPath);
     const archivedStat = await statIfExists(fs, archivedPath);
     if (archivedStat?.isFile()) {
         return { archived: true, path: archivedPath };
@@ -294,12 +303,12 @@ function createdFrontmatter(defaults, input, initialState, mode) {
     const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(defaults.metadata)) {
         if (!reservedKeys.has(key)) {
-            frontmatter[key] = value;
+            setOwnValue(frontmatter, key, value);
         }
     }
     for (const [key, value] of Object.entries(input.metadata ?? {})) {
         if (!reservedKeys.has(key)) {
-            frontmatter[key] = value;
+            setOwnValue(frontmatter, key, value);
         }
     }
     frontmatter.created = new Date().toISOString();
@@ -323,7 +332,7 @@ function updatedFrontmatter(existingFrontmatter, task, patch, mode) {
     const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(patch.metadata ?? {})) {
         if (!reservedKeys.has(key)) {
-            nextFrontmatter[key] = value;
+            setOwnValue(nextFrontmatter, key, value);
         }
     }
     return nextFrontmatter;
@@ -349,7 +358,7 @@ function firedFrontmatter(existingFrontmatter, task, to, mode, metadataPatch) {
     const reservedKeys = reservedFrontmatterKeys(mode);
     for (const [key, value] of Object.entries(metadataPatch ?? {})) {
         if (!reservedKeys.has(key)) {
-            nextFrontmatter[key] = value;
+            setOwnValue(nextFrontmatter, key, value);
         }
     }
     return nextFrontmatter;
@@ -374,15 +383,17 @@ function createTasksView(deps, layout, list) {
     const stateMachine = resolveStateMachine(deps.stateMachine);
     const validStates = new Set(stateMachine.states);
     async function readActiveEntries() {
+        await rejectSymbolicLinkComponents(deps.fs, listDirectoryPath);
         const entries = await readDirectoryNames(deps.fs, listDirectoryPath);
         const result = [];
         for (const entryName of entries) {
-            if (isHiddenEntry(entryName) || isLockFile(entryName))
+            if (isHiddenEntry(entryName))
                 continue;
             const parsed = parseActiveFilename(entryName);
             if (!parsed)
                 continue;
             const entryPath = path.join(listDirectoryPath, entryName);
+            await rejectSymbolicLinkComponents(deps.fs, entryPath);
             const entryStat = await statIfExists(deps.fs, entryPath);
             if (!entryStat?.isFile())
                 continue;
@@ -409,12 +420,14 @@ function createTasksView(deps, layout, list) {
     }
     async function readArchivedTasks() {
         const archivePath = archiveDirectoryPath(deps.path, layout, list);
+        await rejectSymbolicLinkComponents(deps.fs, archivePath);
         const entries = await readDirectoryNames(deps.fs, archivePath);
         const result = [];
         for (const entryName of entries) {
-            if (isHiddenEntry(entryName) || isLockFile(entryName) || !isMarkdownFile(entryName))
+            if (isHiddenEntry(entryName) || !isMarkdownFile(entryName))
                 continue;
             const entryPath = path.join(archivePath, entryName);
+            await rejectSymbolicLinkComponents(deps.fs, entryPath);
             const entryStat = await statIfExists(deps.fs, entryPath);
             if (!entryStat?.isFile())
                 continue;
@@ -438,12 +451,32 @@ function createTasksView(deps, layout, list) {
                 const fromPath = path.join(listDirectoryPath, entry.filename);
                 const stagingPath = path.join(listDirectoryPath, `${desiredFilename}.staging-${process.pid}-${index}`);
                 const targetPath = path.join(listDirectoryPath, desiredFilename);
-                await deps.fs.rename(fromPath, stagingPath);
-                staged.push({ from: stagingPath, to: targetPath });
+                try {
+                    await deps.fs.rename(fromPath, stagingPath);
+                    staged.push({ original: fromPath, staging: stagingPath, target: targetPath, finalized: false });
+                }
+                catch (error) {
+                    for (const stagedEntry of staged.reverse()) {
+                        await deps.fs.rename(stagedEntry.staging, stagedEntry.original);
+                    }
+                    throw error;
+                }
+            }
+        }
+        try {
+            for (const entry of staged) {
+                await deps.fs.rename(entry.staging, entry.target);
+                entry.finalized = true;
             }
         }
-        for (const entry of staged) {
-            await deps.fs.rename(entry.from, entry.to);
+        catch (error) {
+            for (const entry of staged.filter((stagedEntry) => stagedEntry.finalized).reverse()) {
+                await deps.fs.rename(entry.target, entry.staging);
+            }
+            for (const entry of staged.reverse()) {
+                await deps.fs.rename(entry.staging, entry.original);
+            }
+            throw error;
         }
     }
     async function rewriteListPrefixes(orderedIds) {
@@ -524,37 +557,6 @@ function createTasksView(deps, layout, list) {
             await renameActiveEntries(entries, desiredOrdersById);
         }
     }
-    async function withListLock(action) {
-        await deps.fs.mkdir(listDirectoryPath, { recursive: true });
-        const release = await acquireFileLock(path.join(listDirectoryPath, ORDER_LOCK_FILENAME), {
-            fs: deps.fs,
-            staleMs: deps.lockStaleMs,
-            retries: deps.lockRetries
-        });
-        try {
-            return await action();
-        }
-        finally {
-            await release();
-        }
-    }
-    async function withTaskLock(id, action) {
-        validateTaskId(id);
-        return withListLock(action);
-    }
-    async function withLocatedTaskLock(location, action) {
-        const release = await acquireFileLock(location.path, {
-            fs: deps.fs,
-            staleMs: deps.lockStaleMs,
-            retries: deps.lockRetries
-        });
-        try {
-            return await action();
-        }
-        finally {
-            await release();
-        }
-    }
     async function getTaskFile(id) {
         validateTaskId(id);
         return readTaskAtLocation(deps.fs, deps.path, layout, list, id, validStates, stateMachine.initial, deps.frontmatterMode);
@@ -599,8 +601,8 @@ function createTasksView(deps, layout, list) {
             assertCreateDoesNotSetState(input);
             assertCreateHasId(input);
             validateTaskId(input.id);
-            await deps.fs.mkdir(listDirectoryPath, { recursive: true });
-            return withListLock(async () => {
+            await rejectSymbolicLinkComponents(deps.fs, listDirectoryPath);
+            return withFileLock(deps.fs, path.join(listDirectoryPath, ".transition.lock"), async () => {
                 const existing = await findTaskLocation(deps.fs, deps.path, layout, list, input.id);
                 if (existing) {
                     throw new TaskAlreadyExistsError(`Task "${list}/${input.id}" already exists.`);
@@ -619,13 +621,12 @@ function createTasksView(deps, layout, list) {
         },
         async update(id, patch) {
             assertUpdateDoesNotSetState(patch);
-            return withTaskLock(id, async () => {
-                const existing = await getTaskFile(id);
-                const nextFrontmatter = updatedFrontmatter(existing.frontmatter, existing.task, patch, deps.frontmatterMode);
-                const description = patch.description ?? existing.task.description;
-                await writeAtomically(deps.fs, existing.path, serializeTaskDocument(nextFrontmatter, description));
-                return createTask(list, id, nextFrontmatter, description, deps.frontmatterMode, existing.path);
-            });
+            validateTaskId(id);
+            const existing = await getTaskFile(id);
+            const nextFrontmatter = updatedFrontmatter(existing.frontmatter, existing.task, patch, deps.frontmatterMode);
+            const description = patch.description ?? existing.task.description;
+            await writeAtomically(deps.fs, existing.path, serializeTaskDocument(nextFrontmatter, description));
+            return createTask(list, id, nextFrontmatter, description, deps.frontmatterMode, existing.path);
         },
         async fire(id, eventName, opts) {
             const fireTask = async () => {
@@ -645,33 +646,38 @@ function createTasksView(deps, layout, list) {
                 const serializedTask = serializeTaskDocument(nextFrontmatter, existing.task.description);
                 if (event.to === "archived") {
                     const targetPath = archivedTaskPath(deps.path, layout, list, id);
+                    await rejectSymbolicLinkComponents(deps.fs, archiveDirectoryPath(deps.path, layout, list));
                     const archivedTargetExists = await statIfExists(deps.fs, targetPath);
                     if (archivedTargetExists?.isFile()) {
                         throw new TaskAlreadyExistsError(`Task "${list}/${id}" already exists in archive.`);
                     }
-                    await writeAtomically(deps.fs, existing.path, serializedTask);
                     await deps.fs.mkdir(archiveDirectoryPath(deps.path, layout, list), { recursive: true });
-                    await deps.fs.rename(existing.path, targetPath);
+                    await writeAtomically(deps.fs, targetPath, serializedTask);
+                    try {
+                        await deps.fs.unlink(existing.path);
+                    }
+                    catch (error) {
+                        await deps.fs.unlink(targetPath);
+                        throw error;
+                    }
                     const nextTask = createTask(list, id, nextFrontmatter, existing.task.description, deps.frontmatterMode, targetPath);
-                    await event.onEnter?.(nextTask);
-                    return nextTask;
+                    return { event, nextTask };
                 }
                 await writeAtomically(deps.fs, existing.path, serializedTask);
                 const nextTask = createTask(list, id, nextFrontmatter, existing.task.description, deps.frontmatterMode, existing.path);
-                await event.onEnter?.(nextTask);
-                return nextTask;
+                return { event, nextTask };
             };
             if (stateMachine.events[eventName]?.to === "archived") {
                 validateTaskId(id);
-                return withListLock(async () => {
-                    const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
-                    if (!location) {
-                        throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
-                    }
-                    return withLocatedTaskLock(location, fireTask);
-                });
+                const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
+                if (!location) {
+                    throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+                }
             }
-            return withTaskLock(id, fireTask);
+            validateTaskId(id);
+            const { event, nextTask } = await withFileLock(deps.fs, path.join(listDirectoryPath, ".transition.lock"), fireTask);
+            await event.onEnter?.(nextTask);
+            return nextTask;
         },
         async canFire(id, eventName) {
             const task = (await getTaskFile(id)).task;
@@ -686,58 +692,53 @@ function createTasksView(deps, layout, list) {
             return eventsFromState(stateMachine, task.state);
         },
         async delete(id) {
-            await withTaskLock(id, async () => {
-                const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
-                if (!location) {
-                    throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
-                }
-                await deps.fs.unlink(location.path);
-            });
+            validateTaskId(id);
+            const location = await findTaskLocation(deps.fs, deps.path, layout, list, id);
+            if (!location) {
+                throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+            }
+            await deps.fs.unlink(location.path);
         },
         async move(id, anchor) {
             validateTaskId(id);
-            return withListLock(async () => {
-                const { entries } = await readActiveTasks();
-                const fromIndex = entries.findIndex((entry) => entry.id === id);
-                if (fromIndex < 0) {
-                    throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
-                }
-                const ordered = entries.map((entry) => entry.id);
-                ordered.splice(fromIndex, 1);
-                let insertIndex;
-                if ("position" in anchor) {
-                    insertIndex = anchor.position === "top" ? 0 : ordered.length;
-                }
-                else {
-                    const anchorId = "before" in anchor ? anchor.before : anchor.after;
-                    const anchorIndex = ordered.indexOf(anchorId);
-                    if (anchorIndex < 0) {
-                        throw new AnchorNotFoundError(anchorId);
-                    }
-                    insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
+            const { entries } = await readActiveTasks();
+            const fromIndex = entries.findIndex((entry) => entry.id === id);
+            if (fromIndex < 0) {
+                throw new TaskNotFoundError(`Task "${list}/${id}" not found.`);
+            }
+            const ordered = entries.map((entry) => entry.id);
+            ordered.splice(fromIndex, 1);
+            let insertIndex;
+            if ("position" in anchor) {
+                insertIndex = anchor.position === "top" ? 0 : ordered.length;
+            }
+            else {
+                const anchorId = "before" in anchor ? anchor.before : anchor.after;
+                const anchorIndex = ordered.indexOf(anchorId);
+                if (anchorIndex < 0) {
+                    throw new AnchorNotFoundError(anchorId);
                 }
-                ordered.splice(insertIndex, 0, id);
-                await rewriteMovedPrefix(id, ordered);
-                return (await getTaskFile(id)).task;
-            });
+                insertIndex = "before" in anchor ? anchorIndex : anchorIndex + 1;
+            }
+            ordered.splice(insertIndex, 0, id);
+            await rewriteMovedPrefix(id, ordered);
+            return (await getTaskFile(id)).task;
         },
         async reorder(ids) {
             for (const id of ids) {
                 validateTaskId(id);
             }
-            return withListLock(async () => {
-                const { entries } = await readActiveTasks();
-                const currentIds = entries.map((entry) => entry.id);
-                const currentSet = new Set(currentIds);
-                const inputSet = new Set(ids);
-                const missing = currentIds.filter((id) => !inputSet.has(id));
-                const extra = ids.filter((id) => !currentSet.has(id));
-                if (missing.length > 0 || extra.length > 0) {
-                    throw new OrderMismatchError({ missing, extra });
-                }
-                await rewriteListPrefixes(ids);
-                return Promise.all(ids.map(async (id) => (await getTaskFile(id)).task));
-            });
+            const { entries } = await readActiveTasks();
+            const currentIds = entries.map((entry) => entry.id);
+            const currentSet = new Set(currentIds);
+            const inputSet = new Set(ids);
+            const missing = currentIds.filter((id) => !inputSet.has(id));
+            const extra = ids.filter((id) => !currentSet.has(id));
+            if (inputSet.size !== ids.length || missing.length > 0 || extra.length > 0) {
+                throw new OrderMismatchError({ missing, extra });
+            }
+            await rewriteListPrefixes(ids);
+            return Promise.all(ids.map(async (id) => (await getTaskFile(id)).task));
         }
     };
 }
@@ -763,12 +764,11 @@ export async function markdownDirBackend(deps) {
         const entries = await readDirectoryNames(deps.fs, deps.path);
         const result = [];
         for (const entryName of entries) {
-            if (entryName === ARCHIVE_DIRECTORY_NAME ||
-                isHiddenEntry(entryName) ||
-                isLockFile(entryName)) {
+            if (entryName === ARCHIVE_DIRECTORY_NAME || isHiddenEntry(entryName)) {
                 continue;
             }
             const entryPath = path.join(deps.path, entryName);
+            await rejectSymbolicLinkComponents(deps.fs, entryPath);
             const entryStat = await statIfExists(deps.fs, entryPath);
             if (entryStat?.isDirectory()) {
                 result.push(entryName);
@@ -798,44 +798,46 @@ export async function markdownDirBackend(deps) {
             const file = await readTaskAtLocation(deps.fs, deps.path, layout, sourceListName, id, validStates, stateMachine.initial, deps.frontmatterMode);
             return file.task;
         }
-        const targetExisting = await findTaskLocation(deps.fs, deps.path, layout, targetListName, id);
-        if (targetExisting) {
-            throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
-        }
-        const sourceLocation = await findTaskLocation(deps.fs, deps.path, layout, sourceListName, id);
-        if (!sourceLocation) {
-            throw new TaskNotFoundError(`Task "${sourceListName}/${id}" not found.`);
-        }
         const targetListDir = listPath(deps.path, layout, targetListName);
-        await deps.fs.mkdir(targetListDir, { recursive: true });
-        const targetEntries = await (async () => {
-            const out = [];
-            const names = await readDirectoryNames(deps.fs, targetListDir);
-            for (const entryName of names) {
-                if (isHiddenEntry(entryName) || isLockFile(entryName))
-                    continue;
-                const parsed = parseActiveFilename(entryName);
-                if (!parsed)
-                    continue;
-                out.push({ id: parsed.id, order: parsed.order, filename: entryName });
+        await rejectSymbolicLinkComponents(deps.fs, targetListDir);
+        return withFileLock(deps.fs, path.join(targetListDir, ".transition.lock"), async () => {
+            const targetExisting = await findTaskLocation(deps.fs, deps.path, layout, targetListName, id);
+            if (targetExisting) {
+                throw new TaskAlreadyExistsError(`Task "${targetListName}/${id}" already exists.`);
             }
-            return out;
-        })();
-        if (sourceLocation.archived) {
-            const archivedTargetDir = archiveDirectoryPath(deps.path, layout, targetListName);
-            await deps.fs.mkdir(archivedTargetDir, { recursive: true });
-            const archivedTargetPath = archivedTaskPath(deps.path, layout, targetListName, id);
-            await deps.fs.rename(sourceLocation.path, archivedTargetPath);
-            const file = await readTaskFile(deps.fs, targetListName, id, archivedTargetPath, validStates, stateMachine.initial, deps.frontmatterMode);
-            return file.task;
-        }
-        const maxOrder = targetEntries.reduce((max, entry) => (entry.order !== null && entry.order > max ? entry.order : max), 0);
-        const width = padWidthForCount(targetEntries.length + 1);
-        const targetFilename = activeTaskFilename(id, maxOrder + 1, width);
-        const targetPath = path.join(targetListDir, targetFilename);
-        await deps.fs.rename(sourceLocation.path, targetPath);
-        const file = await readTaskFile(deps.fs, targetListName, id, targetPath, validStates, stateMachine.initial, deps.frontmatterMode);
-        return file.task;
+            const sourceLocation = await findTaskLocation(deps.fs, deps.path, layout, sourceListName, id);
+            if (!sourceLocation) {
+                throw new TaskNotFoundError(`Task "${sourceListName}/${id}" not found.`);
+            }
+            const sourceFile = await readTaskFile(deps.fs, sourceListName, id, sourceLocation.path, validStates, stateMachine.initial, deps.frontmatterMode);
+            const targetEntries = await (async () => {
+                const out = [];
+                const names = await readDirectoryNames(deps.fs, targetListDir);
+                for (const entryName of names) {
+                    if (isHiddenEntry(entryName))
+                        continue;
+                    const parsed = parseActiveFilename(entryName);
+                    if (!parsed)
+                        continue;
+                    out.push({ id: parsed.id, order: parsed.order, filename: entryName });
+                }
+                return out;
+            })();
+            if (sourceLocation.archived) {
+                const archivedTargetDir = archiveDirectoryPath(deps.path, layout, targetListName);
+                await rejectSymbolicLinkComponents(deps.fs, archivedTargetDir);
+                await deps.fs.mkdir(archivedTargetDir, { recursive: true });
+                const archivedTargetPath = archivedTaskPath(deps.path, layout, targetListName, id);
+                await deps.fs.rename(sourceLocation.path, archivedTargetPath);
+                return createTask(targetListName, id, sourceFile.frontmatter, sourceFile.task.description, deps.frontmatterMode, archivedTargetPath);
+            }
+            const maxOrder = targetEntries.reduce((max, entry) => (entry.order !== null && entry.order > max ? entry.order : max), 0);
+            const width = padWidthForCount(targetEntries.length + 1);
+            const targetFilename = activeTaskFilename(id, maxOrder + 1, width);
+            const targetPath = path.join(targetListDir, targetFilename);
+            await deps.fs.rename(sourceLocation.path, targetPath);
+            return createTask(targetListName, id, sourceFile.frontmatter, sourceFile.task.description, deps.frontmatterMode, targetPath);
+        });
     };
     return {
         list,

package/node_modules/@poe-code/task-list/dist/backends/utils.d.ts

@@ -11,4 +11,6 @@ export declare function sortStrings(values: string[]): string[];
 export declare function sortTasks(tasks: Task[]): Task[];
 export declare function validateTaskId(id: string): string;
 export declare function statIfExists(fs: TaskListFs, filePath: string): Promise<Awaited<ReturnType<TaskListFs["stat"]>> | undefined>;
+export declare function rejectSymbolicLinkComponents(fs: TaskListFs, filePath: string): Promise<void>;
 export declare function writeAtomically(fs: TaskListFs, filePath: string, content: string): Promise<void>;
+export declare function withFileLock<T>(fs: TaskListFs, lockPath: string, operation: () => Promise<T>): Promise<T>;

package/node_modules/@poe-code/task-list/dist/backends/utils.js

@@ -57,6 +57,26 @@ export async function statIfExists(fs, filePath) {
         throw error;
     }
 }
+export async function rejectSymbolicLinkComponents(fs, filePath) {
+    const resolvedPath = path.resolve(filePath);
+    const rootPath = path.parse(resolvedPath).root;
+    const components = resolvedPath.slice(rootPath.length).split(path.sep).filter(Boolean);
+    let currentPath = rootPath;
+    for (const component of components) {
+        currentPath = path.join(currentPath, component);
+        try {
+            if ((await fs.lstat(currentPath)).isSymbolicLink()) {
+                throw new Error(`Path "${filePath}" contains a symbolic link.`);
+            }
+        }
+        catch (error) {
+            if (hasErrorCode(error, "ENOENT")) {
+                return;
+            }
+            throw error;
+        }
+    }
+}
 export async function writeAtomically(fs, filePath, content) {
     const tempPath = `${filePath}.tmp-${process.pid}-${tmpFileCounter}`;
     tmpFileCounter += 1;
@@ -77,3 +97,62 @@ export async function writeAtomically(fs, filePath, content) {
         throw error;
     }
 }
+export async function withFileLock(fs, lockPath, operation) {
+    await fs.mkdir(path.dirname(lockPath), { recursive: true });
+    for (;;) {
+        try {
+            await fs.writeFile(lockPath, String(process.pid), { encoding: "utf8", flag: "wx" });
+            break;
+        }
+        catch (error) {
+            if (!hasErrorCode(error, "EEXIST")) {
+                throw error;
+            }
+            if (await removeAbandonedLock(fs, lockPath)) {
+                continue;
+            }
+            await Promise.resolve();
+        }
+    }
+    try {
+        return await operation();
+    }
+    finally {
+        await fs.unlink(lockPath);
+    }
+}
+async function removeAbandonedLock(fs, lockPath) {
+    let content;
+    try {
+        content = await fs.readFile(lockPath, "utf8");
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return true;
+        }
+        throw error;
+    }
+    const owner = Number(content);
+    if (!Number.isInteger(owner) || owner <= 0 || isProcessRunning(owner)) {
+        return false;
+    }
+    try {
+        await fs.unlink(lockPath);
+        return true;
+    }
+    catch (error) {
+        if (hasErrorCode(error, "ENOENT")) {
+            return true;
+        }
+        throw error;
+    }
+}
+function isProcessRunning(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return !hasErrorCode(error, "ESRCH");
+    }
+}