@nowcrew/daemon 0.5.28 → 0.5.30

package/dist/computer-profile-lock.js

@@ -0,0 +1,395 @@
+import { mkdir, open, opendir, readFile, readdir, rename, rm, rmdir, stat, unlink, } from "node:fs/promises";
+import { randomUUID } from "node:crypto";
+import { join } from "node:path";
+import { z } from "zod";
+import { defaultProcessController } from "./execution-journal.js";
+const OwnerSchema = z.object({
+    pid: z.number().int().positive(),
+    processIdentity: z.string().min(1),
+    token: z.string().uuid(),
+    createdAt: z.number().int().nonnegative(),
+}).strict();
+const DEFAULT_TIMEOUT_MS = 30_000;
+const DEFAULT_RETRY_MS = 25;
+const DEFAULT_TEMP_STALE_AGE_MS = 24 * 60 * 60 * 1_000;
+const DEFAULT_TEMP_SCAN_LIMIT = 64;
+const DEFAULT_TEMP_DELETE_LIMIT = 16;
+const UUID_PATTERN = "[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}";
+const OWNER_NAME_PATTERN = new RegExp(`^owner\\.${UUID_PATTERN}\\.json$`, "i");
+const TEMP_NAME_PATTERN = new RegExp(`^\\.save\\.lock\\.(${UUID_PATTERN})\\.tmp$`, "i");
+const codeOf = (error) => error instanceof Error && "code" in error ? error.code : undefined;
+const ownerName = (token) => `owner.${token}.json`;
+export const defaultProfileSaveLockFileSystem = {
+    mkdir,
+    readFile: (path) => readFile(path, "utf8"),
+    readDirectoryEntries: async (path, limit) => {
+        const directory = await opendir(path);
+        const names = [];
+        try {
+            while (names.length < limit) {
+                const entry = await directory.read();
+                if (entry === null)
+                    break;
+                names.push(entry.name);
+            }
+        }
+        finally {
+            await directory.close();
+        }
+        return names;
+    },
+    readdir: async (path) => readdir(path),
+    rename,
+    rm,
+    rmdir,
+    stat,
+    unlink,
+    writeDurableFile: async (path, contents) => {
+        const handle = await open(path, "wx", 0o600);
+        try {
+            await handle.writeFile(contents, "utf8");
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+    },
+};
+async function readGeneration(lockDirectory, fileSystem) {
+    let names;
+    try {
+        names = (await fileSystem.readdir(lockDirectory)).sort();
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT")
+            return { status: "absent" };
+        throw error;
+    }
+    if (names.length === 0)
+        return { status: "absent" };
+    if (names.length !== 1 || names[0] !== "generation") {
+        throw new Error(`Invalid profile save lock: ${lockDirectory}`);
+    }
+    const generationDirectory = join(lockDirectory, "generation");
+    try {
+        names = (await fileSystem.readdir(generationDirectory)).sort();
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT")
+            return { status: "absent" };
+        throw error;
+    }
+    if (names.length === 0)
+        return { status: "empty" };
+    if (names.length !== 1 || !OWNER_NAME_PATTERN.test(names[0])) {
+        throw new Error(`Invalid profile save lock generation: ${generationDirectory}`);
+    }
+    const fileName = names[0];
+    const ownerPath = join(generationDirectory, fileName);
+    try {
+        const owner = OwnerSchema.parse(JSON.parse(await fileSystem.readFile(ownerPath)));
+        if (fileName !== ownerName(owner.token))
+            throw new Error("owner token does not match filename");
+        return { status: "owned", owner, fileName };
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT")
+            return { status: "absent" };
+        throw new Error(`Invalid profile save lock owner: ${ownerPath}`, { cause: error });
+    }
+}
+function sameOwner(left, right) {
+    return left.pid === right.pid
+        && left.processIdentity === right.processIdentity
+        && left.token === right.token
+        && left.createdAt === right.createdAt;
+}
+async function requireOwnGeneration(lockDirectory, expected, fileSystem) {
+    const observed = await readGeneration(lockDirectory, fileSystem);
+    if (observed.status !== "owned" || !sameOwner(observed.owner, expected)) {
+        throw new Error(`Profile save lock generation changed during install: ${lockDirectory}`);
+    }
+    return { fileName: observed.fileName };
+}
+async function removeOwnGeneration(lockDirectory, expected, fileSystem) {
+    const observed = await readGeneration(lockDirectory, fileSystem);
+    if (observed.status !== "owned" || !sameOwner(observed.owner, expected))
+        return false;
+    const generationDirectory = join(lockDirectory, "generation");
+    try {
+        await fileSystem.unlink(join(generationDirectory, observed.fileName));
+    }
+    catch (error) {
+        if (codeOf(error) === "ENOENT")
+            return false;
+        throw error;
+    }
+    try {
+        await fileSystem.rmdir(generationDirectory);
+    }
+    catch (error) {
+        if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+            throw error;
+    }
+    try {
+        await fileSystem.rmdir(lockDirectory);
+    }
+    catch (error) {
+        if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+            throw error;
+    }
+    return true;
+}
+function positiveInteger(value, name) {
+    if (!Number.isSafeInteger(value) || value <= 0)
+        throw new RangeError(`${name} must be a positive integer`);
+    return value;
+}
+async function inspectTemporaryGeneration(temporaryDirectory, token, fileSystem) {
+    let entries;
+    try {
+        entries = (await fileSystem.readdir(temporaryDirectory)).sort();
+    }
+    catch (error) {
+        return codeOf(error) === "ENOENT" ? null : { status: "unavailable" };
+    }
+    if (entries.length !== 1 || entries[0] !== ownerName(token)) {
+        return { status: "missing-or-corrupt" };
+    }
+    let contents;
+    try {
+        contents = await fileSystem.readFile(join(temporaryDirectory, entries[0]));
+    }
+    catch (error) {
+        return codeOf(error) === "ENOENT" ? null : { status: "unavailable" };
+    }
+    try {
+        const owner = OwnerSchema.parse(JSON.parse(contents));
+        return owner.token.toLowerCase() === token
+            ? { status: "valid", owner }
+            : { status: "missing-or-corrupt" };
+    }
+    catch {
+        return { status: "missing-or-corrupt" };
+    }
+}
+async function cleanupStaleTemporaryGenerations(options) {
+    const names = await options.fileSystem.readDirectoryEntries(options.profilesDirectory, options.scanLimit);
+    let deleted = 0;
+    for (const name of names) {
+        if (deleted >= options.deleteLimit)
+            break;
+        const match = TEMP_NAME_PATTERN.exec(name);
+        const token = match?.[1]?.toLowerCase();
+        if (token === undefined)
+            continue;
+        const temporaryDirectory = join(options.profilesDirectory, name);
+        let directoryMtimeMs;
+        try {
+            directoryMtimeMs = (await options.fileSystem.stat(temporaryDirectory)).mtimeMs;
+        }
+        catch (error) {
+            if (codeOf(error) === "ENOENT")
+                continue;
+            continue;
+        }
+        const inspection = await inspectTemporaryGeneration(temporaryDirectory, token, options.fileSystem);
+        if (inspection === null || inspection.status === "unavailable")
+            continue;
+        let removable = false;
+        if (inspection.status === "valid") {
+            try {
+                removable = await options.processController.inspectIdentity(inspection.owner.pid)
+                    !== inspection.owner.processIdentity;
+            }
+            catch {
+                removable = false;
+            }
+        }
+        else {
+            removable = options.now - directoryMtimeMs >= options.staleAgeMs;
+        }
+        if (!removable)
+            continue;
+        const confirmed = await inspectTemporaryGeneration(temporaryDirectory, token, options.fileSystem);
+        if (confirmed === null || confirmed.status !== inspection.status)
+            continue;
+        if (inspection.status === "valid") {
+            if (confirmed.status !== "valid" || !sameOwner(confirmed.owner, inspection.owner))
+                continue;
+        }
+        else {
+            try {
+                if ((await options.fileSystem.stat(temporaryDirectory)).mtimeMs !== directoryMtimeMs)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+        }
+        try {
+            await options.fileSystem.rm(temporaryDirectory, { recursive: true, force: true });
+            deleted += 1;
+        }
+        catch {
+            // Stale-temp cleanup is bounded best effort and must not block a profile save.
+        }
+    }
+}
+export async function acquireProfileSaveLock(profilesDirectory, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const retryMs = options.retryMs ?? DEFAULT_RETRY_MS;
+    const now = options.now ?? Date.now;
+    const wait = options.wait ?? ((milliseconds) => new Promise((resolveWait) => setTimeout(resolveWait, milliseconds)));
+    const processController = options.processController ?? defaultProcessController;
+    const fileSystem = options.fileSystem ?? defaultProfileSaveLockFileSystem;
+    const tempStaleAgeMs = options.tempStaleAgeMs ?? DEFAULT_TEMP_STALE_AGE_MS;
+    const tempScanLimit = positiveInteger(options.tempScanLimit ?? DEFAULT_TEMP_SCAN_LIMIT, "tempScanLimit");
+    const tempDeleteLimit = positiveInteger(options.tempDeleteLimit ?? DEFAULT_TEMP_DELETE_LIMIT, "tempDeleteLimit");
+    if (!Number.isFinite(tempStaleAgeMs) || tempStaleAgeMs < 0) {
+        throw new RangeError("tempStaleAgeMs must be a nonnegative finite number");
+    }
+    const deadline = now() + timeoutMs;
+    const lockDirectory = join(profilesDirectory, ".save.lock");
+    const generationDirectory = join(lockDirectory, "generation");
+    const token = randomUUID();
+    const fileName = ownerName(token);
+    const temporaryDirectory = join(profilesDirectory, `.save.lock.${token}.tmp`);
+    await fileSystem.mkdir(profilesDirectory, { recursive: true, mode: 0o700 });
+    await cleanupStaleTemporaryGenerations({
+        profilesDirectory,
+        now: now(),
+        staleAgeMs: tempStaleAgeMs,
+        scanLimit: tempScanLimit,
+        deleteLimit: tempDeleteLimit,
+        processController,
+        fileSystem,
+    });
+    const processIdentity = await processController.inspectIdentity(process.pid);
+    if (processIdentity === null || processIdentity.trim().length === 0) {
+        throw new Error("Failed to capture profile save lock owner process identity");
+    }
+    const owner = OwnerSchema.parse({ pid: process.pid, processIdentity, token, createdAt: now() });
+    let temporaryDirectoryCreated = false;
+    let installed = false;
+    let acquired = false;
+    const pause = async () => {
+        const remaining = deadline - now();
+        if (remaining <= 0)
+            throw new Error(`Timed out waiting for profile save lock: ${lockDirectory}`);
+        await wait(Math.min(retryMs, remaining));
+    };
+    try {
+        await fileSystem.mkdir(temporaryDirectory, { mode: 0o700 });
+        temporaryDirectoryCreated = true;
+        await fileSystem.writeDurableFile(join(temporaryDirectory, fileName), `${JSON.stringify(owner)}\n`);
+        await options.hooks?.beforeInstall?.(owner);
+        for (;;) {
+            try {
+                await fileSystem.mkdir(lockDirectory, { mode: 0o700 });
+            }
+            catch (error) {
+                if (codeOf(error) !== "EEXIST")
+                    throw error;
+            }
+            let renameFailure;
+            try {
+                await fileSystem.rename(temporaryDirectory, generationDirectory);
+                installed = true;
+                await requireOwnGeneration(lockDirectory, owner, fileSystem);
+                acquired = true;
+                let released = false;
+                return async () => {
+                    if (released)
+                        return;
+                    if (!await removeOwnGeneration(lockDirectory, owner, fileSystem)) {
+                        throw new Error(`Profile save lock generation changed before release: ${lockDirectory}`);
+                    }
+                    released = true;
+                };
+            }
+            catch (error) {
+                if (installed)
+                    throw error;
+                if (codeOf(error) === "ENOENT") {
+                    await pause();
+                    continue;
+                }
+                if (codeOf(error) !== "EEXIST"
+                    && codeOf(error) !== "ENOTEMPTY"
+                    && codeOf(error) !== "EPERM"
+                    && codeOf(error) !== "EACCES")
+                    throw error;
+                renameFailure = error;
+            }
+            const permissionFailure = codeOf(renameFailure) === "EPERM"
+                || codeOf(renameFailure) === "EACCES"
+                ? renameFailure
+                : null;
+            const observed = await readGeneration(lockDirectory, fileSystem);
+            if (observed.status === "absent") {
+                if (permissionFailure !== null)
+                    throw permissionFailure;
+                await pause();
+                continue;
+            }
+            if (observed.status === "empty") {
+                try {
+                    await fileSystem.rmdir(generationDirectory);
+                }
+                catch (error) {
+                    if (permissionFailure !== null)
+                        throw permissionFailure;
+                    if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+                        throw error;
+                    await pause();
+                    continue;
+                }
+                try {
+                    await fileSystem.rmdir(lockDirectory);
+                }
+                catch (error) {
+                    if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+                        throw error;
+                }
+                await pause();
+                continue;
+            }
+            const identity = await processController.inspectIdentity(observed.owner.pid);
+            if (identity === observed.owner.processIdentity) {
+                await pause();
+                continue;
+            }
+            try {
+                await fileSystem.unlink(join(generationDirectory, observed.fileName));
+            }
+            catch (error) {
+                if (codeOf(error) === "ENOENT")
+                    continue;
+                throw error;
+            }
+            try {
+                await fileSystem.rmdir(generationDirectory);
+            }
+            catch (error) {
+                if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+                    throw error;
+            }
+            try {
+                await fileSystem.rmdir(lockDirectory);
+            }
+            catch (error) {
+                if (codeOf(error) !== "ENOENT" && codeOf(error) !== "ENOTEMPTY")
+                    throw error;
+            }
+        }
+    }
+    finally {
+        if (!installed && temporaryDirectoryCreated) {
+            await fileSystem.rm(temporaryDirectory, { recursive: true, force: true }).catch(() => undefined);
+        }
+        else if (!acquired) {
+            await removeOwnGeneration(lockDirectory, owner, fileSystem).catch(() => undefined);
+        }
+    }
+}