@nowcrew/daemon 0.5.19 → 0.5.20

package/dist/attachments.js

@@ -2,6 +2,10 @@ import { mkdir, rm, writeFile } from "node:fs/promises";
 import { basename, extname, resolve, sep } from "node:path";
 export const ATTACHMENT_MAX_FILE_BYTES = 25 * 1024 * 1024;
 export const ATTACHMENT_MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+const throwIfAborted = (signal) => {
+    if (signal?.aborted)
+        throw signal.reason ?? new Error("Attachment materialization aborted");
+};
 function truncateUtf8(value, maxBytes) {
     let bytes = 0;
     let output = "";
@@ -74,7 +78,15 @@ async function downloadAttachment(input) {
     }
     let current = initial;
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), input.timeoutMs);
+    let timedOut = false;
+    const onAbort = () => controller.abort(input.signal?.reason ?? new Error("Attachment materialization aborted"));
+    input.signal?.addEventListener("abort", onAbort, { once: true });
+    if (input.signal?.aborted)
+        onAbort();
+    const timer = setTimeout(() => {
+        timedOut = true;
+        controller.abort(new Error(`Attachment download timed out after ${input.timeoutMs}ms`));
+    }, input.timeoutMs);
     try {
         let response = await input.fetchImpl(current, {
             redirect: "manual",
@@ -93,22 +105,37 @@ async function downloadAttachment(input) {
         if (!response.ok)
             throw new Error(`Attachment download failed with status ${response.status}`);
         const data = await readBounded(response, input.maxFileBytes);
+        throwIfAborted(input.signal);
         if (data.length !== input.attachment.sizeBytes) {
             throw new Error(`Attachment size mismatch: expected ${input.attachment.sizeBytes}, received ${data.length}`);
         }
         return data;
     }
     catch (error) {
-        if (controller.signal.aborted) {
+        if (input.signal?.aborted) {
+            throw input.signal.reason ?? new Error("Attachment materialization aborted");
+        }
+        if (timedOut) {
             throw new Error(`Attachment download timed out after ${input.timeoutMs}ms`);
         }
         throw error;
     }
     finally {
         clearTimeout(timer);
+        input.signal?.removeEventListener("abort", onAbort);
+    }
+}
+export function executionAttachmentDirectory(runDir, executionId) {
+    const attachmentsRoot = resolve(runDir, "attachments");
+    const executionKey = executionId.replace(/[^A-Za-z0-9._-]/gu, "_");
+    const directory = resolve(attachmentsRoot, executionKey);
+    if (!directory.startsWith(`${attachmentsRoot}${sep}`)) {
+        throw new Error("Attachment directory escapes the run directory");
     }
+    return directory;
 }
 export async function materializeAttachments(input) {
+    throwIfAborted(input.signal);
     const maxFileBytes = input.maxFileBytes ?? ATTACHMENT_MAX_FILE_BYTES;
     const maxTotalBytes = input.maxTotalBytes ?? ATTACHMENT_MAX_TOTAL_BYTES;
     const total = input.attachments.reduce((sum, attachment) => sum + attachment.sizeBytes, 0);
@@ -116,17 +143,14 @@ export async function materializeAttachments(input) {
         || total > maxTotalBytes) {
         throw new Error("Attachment metadata exceeds the configured byte limit");
     }
-    const attachmentsRoot = resolve(input.runDir, "attachments");
-    const executionKey = input.executionId.replace(/[^A-Za-z0-9._-]/gu, "_");
-    const directory = resolve(attachmentsRoot, executionKey);
-    if (!directory.startsWith(`${attachmentsRoot}${sep}`)) {
-        throw new Error("Attachment directory escapes the run directory");
-    }
-    await rm(directory, { recursive: true, force: true });
-    await mkdir(directory, { recursive: true, mode: 0o700 });
+    const directory = executionAttachmentDirectory(input.runDir, input.executionId);
     const used = new Set();
     const materialized = [];
     try {
+        await rm(directory, { recursive: true, force: true });
+        throwIfAborted(input.signal);
+        await mkdir(directory, { recursive: true, mode: 0o700 });
+        throwIfAborted(input.signal);
         for (const attachment of input.attachments) {
             const base = safeFilename(attachment.filename);
             let collision = 1;
@@ -145,14 +169,25 @@ export async function materializeAttachments(input) {
                 maxFileBytes,
                 maxRedirects: input.maxRedirects ?? 3,
                 timeoutMs: input.timeoutMs ?? 10_000,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
+            });
+            throwIfAborted(input.signal);
+            await writeFile(path, data, {
+                flag: "wx",
+                mode: 0o600,
+                ...(input.signal === undefined ? {} : { signal: input.signal }),
             });
-            await writeFile(path, data, { flag: "wx", mode: 0o600 });
             materialized.push({ ...attachment, filename, path });
         }
         return { directory, attachments: materialized };
     }
     catch (error) {
-        await rm(directory, { recursive: true, force: true });
+        try {
+            await rm(directory, { recursive: true, force: true });
+        }
+        catch (cleanupError) {
+            throw new AggregateError([error, cleanupError], "Attachment materialization failed and its execution directory could not be removed");
+        }
         throw error;
     }
 }

package/dist/computer-cli.js

@@ -2,8 +2,10 @@ import { parseArgs } from "node:util";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { daemonHome, listProfiles, loadProfile, profileIsPrivate, profilePath, publicProfile, removeProfile, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
+import { assertProfileAgentsRootUnique, daemonHome, inspectProfileAgentsRoot, listProfiles, loadProfile, PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, ProfileAgentsRootConflictError, profileIsPrivate, profilePath, publicProfile, removeProfile, resolveAgentsRoot, saveProfile, windowsDpapiProtector, } from "./computer-profile.js";
 import { buildServiceSpec, doctorService, hardenWindowsProfile, installService, serviceAction, serviceStatus, systemCommandRunner, uninstallService, upgradeDaemon, windowsProfileIsPrivate, } from "./computer-service.js";
+import { defaultProcessController } from "./execution-journal.js";
+import { inspectJournalLock } from "./execution-journal-lock.js";
 import { detectDaemonLang, formatDaemonText } from "./i18n.js";
 const COMPUTER_COMMANDS = new Set(["profile", "doctor", "install", "uninstall", "start", "stop", "restart", "status", "upgrade"]);
 export function builtDaemonEntry(moduleUrl = import.meta.url) {
@@ -60,6 +62,17 @@ function requireValue(value, name, td) {
         throw new Error(td("Missing {{name}}", { name }));
     return value;
 }
+function translatedError(error, td) {
+    if (error instanceof ProfileAgentsRootConflictError) {
+        return td(PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, {
+            profile: error.profile,
+            conflict: error.conflict,
+            agentsRoot: error.agentsRoot,
+            command: error.command,
+        });
+    }
+    return td(error.message);
+}
 export async function runComputerCommand(argv, overrides = {}) {
     const command = argv[0];
     if (!command || !COMPUTER_COMMANDS.has(command))
@@ -88,6 +101,7 @@ export async function runComputerCommand(argv, overrides = {}) {
         const home = daemonHome(deps.env);
         const profileStorage = {
             platform: deps.platform,
+            userHome: deps.userHome,
             ...(deps.profileProtector ? { protector: deps.profileProtector } : {}),
             ...(deps.platform === "win32"
                 ? { harden: (path) => hardenWindowsProfile(path, deps.runner) }
@@ -124,22 +138,28 @@ export async function runComputerCommand(argv, overrides = {}) {
             const machineToken = (fromStdin ? await deps.readStdin() : deps.env.CREW_MACHINE_TOKEN)?.trim();
             if (!machineToken)
                 throw new Error(td("Missing machine token; use CREW_MACHINE_TOKEN or --token-stdin"));
-            await saveProfile({
+            const profile = {
                 name,
                 serverUrl: requireValue(parsed.values["server-url"], "--server-url", td),
                 machineToken,
-                ...(parsed.values["agents-root"] ? { agentsRoot: resolve(parsed.values["agents-root"]) } : {}),
+                ...(parsed.values["agents-root"]
+                    ? { agentsRoot: resolveAgentsRoot(parsed.values["agents-root"], deps.userHome, deps.platform) }
+                    : {}),
                 ...(deps.env.PATH ? { runtimePath: deps.env.PATH } : {}),
-            }, home, profileStorage);
+            };
+            await saveProfile(profile, home, profileStorage);
             deps.stdout(`${td("Saved profile '{{name}}' with private credentials.", { name })}\n`);
             return 0;
         }
         const profileName = parsed.values.profile;
         if (command === "upgrade") {
-            const spec = profileName
+            const restartProfile = profileName
+                ? await loadProfile(profileName, home, profileStorage)
+                : null;
+            const spec = restartProfile
                 ? buildServiceSpec({
                     ...deps,
-                    profile: (await loadProfile(profileName, home, profileStorage)).name,
+                    profile: restartProfile.name,
                     profileHome: home,
                 })
                 : null;
@@ -152,9 +172,18 @@ export async function runComputerCommand(argv, overrides = {}) {
                     throw new Error(td("Service '{{id}}' is not installed", { id: spec.id }));
             }
             await upgradeDaemon(deps.platform, deps.runner);
-            if (profileName) {
+            if (restartProfile) {
+                try {
+                    await assertProfileAgentsRootUnique(restartProfile, home, deps.userHome, profileStorage);
+                }
+                catch (error) {
+                    if (!(error instanceof ProfileAgentsRootConflictError))
+                        throw error;
+                    deps.stdout(`${td("Upgraded daemon but skipped restart for '{{name}}': {{reason}}", { name: restartProfile.name, reason: translatedError(error, td) })}\n`);
+                    return 0;
+                }
                 await serviceAction(spec, "restart", deps.runner);
-                deps.stdout(`${td("Upgraded daemon and restart request accepted for '{{name}}'. Verify with status.", { name: profileName })}\n`);
+                deps.stdout(`${td("Upgraded daemon and restart request accepted for '{{name}}'. Verify with status.", { name: restartProfile.name })}\n`);
             }
             else {
                 deps.stdout(`${td("Upgraded daemon. Installed services were not restarted; pass --profile to restart one.")}\n`);
@@ -162,7 +191,10 @@ export async function runComputerCommand(argv, overrides = {}) {
             return 0;
         }
         const name = requireValue(profileName, "--profile", td);
-        await loadProfile(name, home, profileStorage);
+        const profile = await loadProfile(name, home, profileStorage);
+        if (command === "install" || command === "start" || command === "restart") {
+            await assertProfileAgentsRootUnique(profile, home, deps.userHome, profileStorage);
+        }
         if (!deps.entryPath.endsWith(".js")) {
             throw new Error(td("Service lifecycle requires the built daemon entry (.js), not a TypeScript development entry"));
         }
@@ -199,16 +231,44 @@ export async function runComputerCommand(argv, overrides = {}) {
             const privateFile = deps.platform === "win32"
                 ? await windowsProfileIsPrivate(profilePath(name, home), deps.runner)
                 : await profileIsPrivate(name, home, deps.platform);
-            const checks = await doctorService(spec, privateFile, deps.runner);
+            const serviceChecks = await doctorService(spec, privateFile, deps.runner);
+            const rootInspection = await inspectProfileAgentsRoot(profile, home, deps.userHome, profileStorage);
+            const journalPath = resolve(rootInspection.agentsRoot, ".crew", "executions");
+            const journalLock = await inspectJournalLock({
+                directory: journalPath,
+                inspectIdentity: defaultProcessController.inspectIdentity,
+            });
+            const checks = [
+                ...serviceChecks,
+                {
+                    name: "agents-root-unique",
+                    ok: rootInspection.duplicateProfiles.length === 0,
+                    detail: rootInspection.duplicateProfiles.length === 0
+                        ? "unique"
+                        : `also used by: ${rootInspection.duplicateProfiles.join(", ")}`,
+                },
+                {
+                    name: "journal-lock-health",
+                    ok: journalLock.status === "unlocked" || journalLock.status === "owned",
+                    detail: journalLock.detail,
+                },
+            ];
             const registered = (await serviceStatus(spec, deps.runner)).installed;
-            deps.stdout(`${JSON.stringify({ checks, registered }, null, 2)}\n`);
+            deps.stdout(`${JSON.stringify({
+                agentsRoot: rootInspection.agentsRoot,
+                journalPath,
+                duplicateProfiles: rootInspection.duplicateProfiles,
+                journalLock,
+                checks,
+                registered,
+            }, null, 2)}\n`);
             return checks.every((check) => check.ok) ? 0 : 4;
         }
         deps.stderr(usage(td));
         return 2;
     }
     catch (error) {
-        deps.stderr(`crew-daemon: ${td(error.message)}\n`);
+        deps.stderr(`crew-daemon: ${translatedError(error, td)}\n`);
         return 1;
     }
 }

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);
+        }
+    }
+}