@nowcrew/daemon 0.5.18 → 0.5.20

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

package/dist/computer-profile.js

@@ -1,10 +1,13 @@
 import { access, chmod, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
 import { constants } from "node:fs";
+import { realpathSync } from "node:fs";
 import { homedir } from "node:os";
-import { dirname, resolve } from "node:path";
+import { dirname, posix, resolve, win32 } from "node:path";
 import { randomUUID } from "node:crypto";
 import { spawn } from "node:child_process";
 import { z } from "zod";
+import { acquireProfileSaveLock, } from "./computer-profile-lock.js";
+import { formatDaemonText } from "./i18n.js";
 const PROFILE_NAME = /^[a-z0-9][a-z0-9_-]{0,47}$/;
 const ServerUrlSchema = z.string().url().max(2048).refine((value) => {
     const url = new URL(value);
@@ -18,6 +21,11 @@ const ProfileSchema = z.object({
     agentsRoot: z.string().min(1).optional(),
     runtimePath: z.string().min(1).max(32768).refine((value) => !value.includes("\0") && !value.includes("\n") && !value.includes("\r"), "runtimePath must be a single line").optional(),
 }).strict();
+const ProfileAgentsRootCandidateSchema = ProfileSchema.pick({
+    name: true,
+    serverUrl: true,
+    agentsRoot: true,
+}).strict();
 const StoredPlainProfileSchema = ProfileSchema;
 const StoredProtectedProfileSchema = ProfileSchema.omit({ machineToken: true }).extend({
     machineTokenProtected: z.object({
@@ -26,9 +34,93 @@ const StoredProtectedProfileSchema = ProfileSchema.omit({ machineToken: true }).
     }).strict(),
 }).strict();
 const StoredProfileSchema = z.union([StoredPlainProfileSchema, StoredProtectedProfileSchema]);
+export const PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE = "Profile '{{profile}}' conflicts with profile '{{conflict}}': both resolve to agents root '{{agentsRoot}}'. Save it with a unique root, for example: {{command}}";
+export class ProfileAgentsRootConflictError extends Error {
+    profile;
+    conflict;
+    agentsRoot;
+    command;
+    constructor(input) {
+        const quote = input.platform === "win32" ? quotePowerShellArgument : quotePosixArgument;
+        const pathApi = input.platform === "win32" ? win32 : posix;
+        const suggestedRoot = resolveAgentsRoot(pathApi.join(input.userHome, ".crew", `agents-${input.profile}`), input.userHome, input.platform);
+        const command = [
+            "crew-daemon profile save",
+            quote(input.profile),
+            "--server-url",
+            quote(input.serverUrl),
+            "--agents-root",
+            quote(suggestedRoot),
+            "--token-stdin",
+        ].join(" ");
+        super(formatDaemonText("en", PROFILE_AGENTS_ROOT_CONFLICT_MESSAGE, {
+            profile: input.profile,
+            conflict: input.conflict,
+            agentsRoot: input.agentsRoot,
+            command,
+        }));
+        this.name = "ProfileAgentsRootConflictError";
+        this.profile = input.profile;
+        this.conflict = input.conflict;
+        this.agentsRoot = input.agentsRoot;
+        this.command = command;
+    }
+}
+const quotePosixArgument = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+const quotePowerShellArgument = (value) => `'${value.replaceAll("'", "''")}'`;
 export function daemonHome(env = process.env) {
     return resolve(env.CREW_DAEMON_HOME ?? resolve(homedir(), ".crew/daemon"));
 }
+export function resolveAgentsRoot(configured, userHome = homedir(), platform = process.platform) {
+    const pathApi = platform === "win32" ? win32 : posix;
+    const normalizedHome = pathApi.resolve(userHome);
+    if (configured === undefined)
+        return canonicalizeRoot(pathApi.resolve(normalizedHome, ".crew", "agents"), platform);
+    const expanded = configured === "~"
+        ? normalizedHome
+        : configured.startsWith("~/") || (platform === "win32" && configured.startsWith("~\\"))
+            ? pathApi.resolve(normalizedHome, configured.slice(2))
+            : configured;
+    return canonicalizeRoot(pathApi.resolve(expanded), platform);
+}
+function canonicalizeRoot(path, platform) {
+    const compatibleHost = (platform === "win32") === (process.platform === "win32");
+    if (!compatibleHost)
+        return path;
+    try {
+        return realpathSync.native(path);
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOTDIR")
+            return path;
+        if (code !== "ENOENT")
+            throw error;
+    }
+    const pathApi = platform === "win32" ? win32 : posix;
+    const missingSegments = [];
+    let ancestor = path;
+    for (;;) {
+        const parent = pathApi.dirname(ancestor);
+        if (parent === ancestor)
+            return path;
+        missingSegments.unshift(pathApi.basename(ancestor));
+        ancestor = parent;
+        try {
+            return pathApi.resolve(realpathSync.native(ancestor), ...missingSegments);
+        }
+        catch (error) {
+            const code = error.code;
+            if (code === "ENOTDIR")
+                return path;
+            if (code !== "ENOENT")
+                throw error;
+        }
+    }
+}
+function comparableAgentsRoot(path, platform) {
+    return platform === "win32" ? win32.normalize(path).toLocaleLowerCase("en-US") : path;
+}
 export function validateProfileName(name) {
     if (!PROFILE_NAME.test(name)) {
         throw new Error("profile name must match [a-z0-9][a-z0-9_-]{0,47}");
@@ -87,29 +179,74 @@ function storageOptions(options) {
         ...(options.harden ? { harden: options.harden } : {}),
     };
 }
+function attachCleanupError(primaryError, cleanupError) {
+    try {
+        if (!(primaryError instanceof Error)
+            || !Object.isExtensible(primaryError)
+            || Object.prototype.hasOwnProperty.call(primaryError, "cleanupError"))
+            return;
+        Object.defineProperty(primaryError, "cleanupError", {
+            configurable: true,
+            value: cleanupError,
+        });
+    }
+    catch {
+        // Preserve the primary error even when it cannot accept diagnostics.
+    }
+}
 export async function saveProfile(input, home = daemonHome(), options = {}) {
     const profile = ProfileSchema.parse({ version: 1, ...input });
     const configured = storageOptions(options);
-    if (configured.platform === "win32") {
-        if (!configured.protector)
-            throw new Error("Windows profile storage requires CurrentUser DPAPI");
-        if (!configured.harden)
-            throw new Error("Windows profile storage requires ACL hardening");
-        const ciphertext = await configured.protector.protect(profile.machineToken);
-        if (!ciphertext)
-            throw new Error("Windows DPAPI returned an empty ciphertext");
-        const stored = StoredProtectedProfileSchema.parse({
-            version: 1,
-            name: profile.name,
-            serverUrl: profile.serverUrl,
-            ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
-            ...(profile.runtimePath ? { runtimePath: profile.runtimePath } : {}),
-            machineTokenProtected: { scheme: "dpapi-current-user", ciphertext },
-        });
-        await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(stored, null, 2)}\n`, configured.harden);
+    const release = await acquireProfileSaveLock(resolve(home, "profiles"), {
+        ...(options.lockTimeoutMs === undefined ? {} : { timeoutMs: options.lockTimeoutMs }),
+        ...(options.lockRetryMs === undefined ? {} : { retryMs: options.lockRetryMs }),
+        ...(options.lockNow === undefined ? {} : { now: options.lockNow }),
+        ...(options.lockWait === undefined ? {} : { wait: options.lockWait }),
+        ...(options.lockProcessController === undefined
+            ? {}
+            : { processController: options.lockProcessController }),
+        ...(options.lockHooks === undefined ? {} : { hooks: options.lockHooks }),
+    });
+    let bodyFailed = false;
+    let bodyError;
+    try {
+        await assertProfileAgentsRootUnique(profile, home, options.userHome ?? homedir(), options);
+        if (configured.platform === "win32") {
+            if (!configured.protector)
+                throw new Error("Windows profile storage requires CurrentUser DPAPI");
+            if (!configured.harden)
+                throw new Error("Windows profile storage requires ACL hardening");
+            const ciphertext = await configured.protector.protect(profile.machineToken);
+            if (!ciphertext)
+                throw new Error("Windows DPAPI returned an empty ciphertext");
+            const stored = StoredProtectedProfileSchema.parse({
+                version: 1,
+                name: profile.name,
+                serverUrl: profile.serverUrl,
+                ...(profile.agentsRoot ? { agentsRoot: profile.agentsRoot } : {}),
+                ...(profile.runtimePath ? { runtimePath: profile.runtimePath } : {}),
+                machineTokenProtected: { scheme: "dpapi-current-user", ciphertext },
+            });
+            await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(stored, null, 2)}\n`, configured.harden);
+        }
+        else {
+            await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(profile, null, 2)}\n`);
+        }
     }
-    else {
-        await atomicPrivateWrite(profilePath(profile.name, home), `${JSON.stringify(profile, null, 2)}\n`);
+    catch (error) {
+        bodyFailed = true;
+        bodyError = error;
+        throw error;
+    }
+    finally {
+        try {
+            await release();
+        }
+        catch (cleanupError) {
+            if (!bodyFailed)
+                throw cleanupError;
+            attachCleanupError(bodyError, cleanupError);
+        }
     }
     return profile;
 }
@@ -161,6 +298,38 @@ export async function listProfiles(home = daemonHome()) {
         throw error;
     }
 }
+export async function inspectProfileAgentsRoot(profile, home = daemonHome(), userHome = homedir(), options = {}) {
+    const platform = storageOptions(options).platform;
+    const agentsRoot = resolveAgentsRoot(profile.agentsRoot, userHome, platform);
+    const comparableRoot = comparableAgentsRoot(agentsRoot, platform);
+    const names = (await listProfiles(home)).filter((name) => name !== profile.name);
+    const profiles = await Promise.all(names.map((name) => loadProfile(name, home, options)));
+    return {
+        agentsRoot,
+        duplicateProfiles: profiles
+            .filter((candidate) => comparableAgentsRoot(resolveAgentsRoot(candidate.agentsRoot, userHome, platform), platform) === comparableRoot)
+            .map((candidate) => candidate.name),
+    };
+}
+export async function assertProfileAgentsRootUnique(profile, home = daemonHome(), userHome = homedir(), options = {}) {
+    const candidate = ProfileAgentsRootCandidateSchema.parse({
+        name: profile.name,
+        serverUrl: profile.serverUrl,
+        ...(profile.agentsRoot === undefined ? {} : { agentsRoot: profile.agentsRoot }),
+    });
+    const inspection = await inspectProfileAgentsRoot(candidate, home, userHome, options);
+    const conflict = inspection.duplicateProfiles[0];
+    if (conflict === undefined)
+        return;
+    throw new ProfileAgentsRootConflictError({
+        profile: candidate.name,
+        conflict,
+        agentsRoot: inspection.agentsRoot,
+        serverUrl: candidate.serverUrl,
+        userHome,
+        platform: storageOptions(options).platform,
+    });
+}
 export async function removeProfile(name, home = daemonHome()) {
     await rm(profilePath(name, home), { force: true });
 }

package/dist/config.js

@@ -4,6 +4,7 @@ import { dirname, resolve } from "node:path";
 import { homedir } from "node:os";
 import { createRequire } from "node:module";
 import { detectDaemonLang, translateDaemon } from "./i18n.js";
+import { resolveAgentsRoot } from "./computer-profile.js";
 export const DEFAULT_EXECUTION_LIMITS = Object.freeze({
     maxPromptBytes: 256_000,
     maxTimeoutMs: 3_600_000,
@@ -65,7 +66,7 @@ export function loadConfig(env = process.env) {
     return {
         serverUrl,
         machineToken,
-        agentsRoot: env.CREW_AGENTS_ROOT ?? resolve(homedir(), ".crew/agents"),
+        agentsRoot: resolveAgentsRoot(env.CREW_AGENTS_ROOT, homedir()),
         cliPath: env.CREW_CLI_PATH ?? defaultCliPath(),
         runtimeBin: env.CREW_RUNTIME ?? "claude",
         dangerous: env.CREW_RUNTIME_SAFE !== "1", // 默认开启 (headless agent 在自有 workspace 内运行)