@intentic/machine 1.326.0 → 1.328.0

package/dist/sync/mutagen.js

@@ -1,4 +1,5 @@
 import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
 import { existsSync } from "node:fs";
 import { chmod, rm } from "node:fs/promises";
 import { join } from "node:path";
@@ -8,62 +9,149 @@ import { STATE_DIR, WORKSPACE_ROOT } from "@intentic/constants";
 import { clearWindowsRunValue, quotedCommandLine, setWindowsRunValue, stubCommand, windowsLaunchStub, } from "@intentic/local-agent";
 import { binDir } from "../config.js";
 import { archToken, download, exe, osToken, renameIfPresent } from "../release.js";
-import { isProjectPairing, mutagenDaemonLogPath, pairingRemoteDir, projectDirection } from "./config.js";
+import { adoptFolder } from "./project/adopt.js";
+import { clearAdoptFolder, isProjectPairing, mutagenDaemonLogPath, pairingKey, pairingRemoteDir, projectDirection } from "./config.js";
 import { dockerEndpointAnswers, liveIdentity, mutagenForwardUrl, mutagenUrl, pairingEndpoint } from "./endpoint.js";
+import { labelValue, sessionOwner } from "./environment.js";
 import { runProcess } from "./exec.js";
+import { projectShell, realProjectRunner, sandboxCopy } from "./project/project-remote.js";
 import { clearConflictResidue, sweepDerivedResidue } from "./residue.js";
 import { BACKUP_IGNORES, ignoresFor, mutagenSshPath, sanitizeId, sshTransportAnswers } from "./ssh.js";
 import { deviceSymlinks } from "./symlinks.js";
 const MUTAGEN_VERSION = "0.18.1";
+export const MUTAGEN_CALL_TIMEOUT_MS = 60_000;
+export const MUTAGEN_CREATE_TIMEOUT_MS = 5 * 60_000;
 const SESSION_PREFIX = "intentic-";
-export const sessionName = (sandboxId) => `${SESSION_PREFIX}${sanitizeId(sandboxId)}`;
-export const backupSessionName = (sandboxId) => `${sessionName(sandboxId)}-state`;
-export const syncSessionNames = (pairing) => isProjectPairing(pairing) ? [sessionName(pairing.sandboxId)] : [sessionName(pairing.sandboxId), backupSessionName(pairing.sandboxId)];
+export const OWNER_LABEL = "intentic-owner";
+const SANDBOX_LABEL = "intentic-sandbox";
+const KIND_LABEL = "intentic-kind";
+export const sessionLabels = (sandboxId, kind, owner = sessionOwner()) => ({
+    owner,
+    sandbox: labelValue(sanitizeId(sandboxId)),
+    kind,
+});
+export const labelArgs = (labels) => labels === undefined
+    ? []
+    : ["--label", `${OWNER_LABEL}=${labels.owner}`, "--label", `${SANDBOX_LABEL}=${labels.sandbox}`, "--label", `${KIND_LABEL}=${labels.kind}`];
+export const ownershipOf = (labels, owner) => {
+    const said = labels?.[OWNER_LABEL];
+    return said === undefined || said === "" ? "unlabelled" : said === owner ? "ours" : "theirs";
+};
+export const sessionName = (key) => {
+    const at = key.lastIndexOf("~");
+    if (at === -1) {
+        return `${SESSION_PREFIX}${sanitizeId(key)}`;
+    }
+    const name = key.slice(at + 1);
+    const hash = createHash("sha256").update(name).digest("hex").slice(0, 8);
+    return `${SESSION_PREFIX}${sanitizeId(key.slice(0, at))}--${sanitizeId(name)}-${hash}`;
+};
+export const backupSessionName = (key) => `${sessionName(key)}-state`;
+export const syncSessionNames = (pairing) => {
+    if (pairing.projectsHost === true) {
+        return [];
+    }
+    const key = pairingKey(pairing);
+    return isProjectPairing(pairing) ? [sessionName(key)] : [sessionName(key), backupSessionName(key)];
+};
 const FORWARD_PREFIX = "intentic-fwd-";
 export const forwardSessionName = (sandboxId, port) => `${FORWARD_PREFIX}${sanitizeId(sandboxId)}-${port}`;
-const oursIn = (listed, prefix) => listed.split(/\s+/).filter((name) => name.startsWith(prefix));
+const present = (text) => (text === undefined || text === "" ? undefined : text);
+export const listedSessions = (listed) => listed
+    .split(/\s+/)
+    .filter((token) => token !== "")
+    .map((token) => {
+    const [name = "", owner, identifier] = token.split("@");
+    return { name, owner: present(owner), identifier: present(identifier) };
+});
+const isOurs = (session, prefix, owner) => session.name.startsWith(prefix) && (session.owner === undefined || owner === undefined || session.owner === owner);
+const oursIn = (listed, prefix, owner) => listedSessions(listed)
+    .filter((session) => isOurs(session, prefix, owner))
+    .map((session) => session.name);
+export const terminateTargetsIn = (listed, names, prefix, owner) => {
+    const wanted = new Set(names);
+    return listedSessions(listed)
+        .filter((session) => wanted.has(session.name) && isOurs(session, prefix, owner))
+        .map((session) => session.identifier ?? session.name)
+        .filter((target, index, all) => all.indexOf(target) === index);
+};
 const FORWARD_NAME = new RegExp(`^${FORWARD_PREFIX}(.+)-(\\d+)$`);
-export const parseForwardNames = (listed, sandboxId) => {
-    const names = oursIn(listed, FORWARD_PREFIX);
+export const parseForwardNames = (listed, sandboxId, owner) => {
+    const names = oursIn(listed, FORWARD_PREFIX, owner);
     if (sandboxId === undefined) {
         return names;
     }
     const wanted = sanitizeId(sandboxId);
     return names.filter((name) => FORWARD_NAME.exec(name)?.[1] === wanted);
 };
-export const parseOrphanForwardNames = (listed, keptSandboxIds) => {
+export const parseOrphanForwardNames = (listed, keptSandboxIds, owner) => {
     const kept = new Set(keptSandboxIds.map(sanitizeId));
-    return parseForwardNames(listed).filter((name) => {
-        const owner = FORWARD_NAME.exec(name)?.[1];
-        return owner === undefined || !kept.has(owner);
+    return parseForwardNames(listed, undefined, owner).filter((name) => {
+        const held = FORWARD_NAME.exec(name)?.[1];
+        return held === undefined || !kept.has(held);
     });
 };
-export const parseOrphanSyncNames = (listed, keep) => {
+export const parseOrphanSyncNames = (listed, keep, owner) => {
     const kept = new Set(keep);
-    return oursIn(listed, SESSION_PREFIX).filter((name) => !kept.has(name));
+    return oursIn(listed, SESSION_PREFIX, owner).filter((name) => !kept.has(name));
+};
+const LIST_TEMPLATE = `{{range .}}{{.Name}}@{{index .Labels "${OWNER_LABEL}"}}@{{.Identifier}} {{end}}`;
+const VERSION_MISMATCH = /version mismatch/i;
+const DAEMON_RESTART_MS = 30 * 60_000;
+let daemonRestartedAt = Number.NEGATIVE_INFINITY;
+let daemonLog;
+export const sayDaemonEventsTo = (log) => {
+    daemonLog = log;
+};
+export const restartsDaemonFor = (stderr, now, lastRestart) => VERSION_MISMATCH.test(stderr) && now - lastRestart >= DAEMON_RESTART_MS;
+const recoverDaemon = (mutagen, stderr) => {
+    const now = Date.now();
+    if (!restartsDaemonFor(stderr, now, daemonRestartedAt)) {
+        return false;
+    }
+    daemonRestartedAt = now;
+    spawnSync(mutagen, ["daemon", "stop"], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
+    const started = spawnSync(mutagen, ["daemon", "start"], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
+    daemonLog?.(`the Mutagen daemon running here is another version than this agent's (${mutagen}); ${started.status === 0 ? "restarted it with this agent's copy" : "could not restart it"}. Its sessions are kept on disk and come back with it.`);
+    return started.status === 0;
+};
+const listCall = (mutagen, args) => {
+    const run = () => spawnSync(mutagen, [...args], { encoding: "utf8", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
+    const first = run();
+    if (first.status === 0) {
+        return first.stdout;
+    }
+    if (!recoverDaemon(mutagen, first.stderr ?? "")) {
+        return undefined;
+    }
+    const again = run();
+    return again.status === 0 ? again.stdout : undefined;
 };
-const listSessionNames = (mutagen, kind) => {
-    const result = spawnSync(mutagen, [kind, "list", "--template", "{{range .}}{{.Name}} {{end}}"], { encoding: "utf8", windowsHide: true });
-    return result.status === 0 ? result.stdout : "";
+const listSessionNames = (mutagen, kind) => listCall(mutagen, [kind, "list", "--template", LIST_TEMPLATE]);
+export const ourForwardSessions = (mutagen, sandboxId) => {
+    const listed = listSessionNames(mutagen, "forward");
+    return listed === undefined ? undefined : parseForwardNames(listed, sandboxId, sessionOwner());
 };
-export const ourForwardSessions = (mutagen, sandboxId) => parseForwardNames(listSessionNames(mutagen, "forward"), sandboxId);
-export const parseForwardPorts = (listed, sandboxId) => parseForwardNames(listed, sandboxId).flatMap((name) => {
+export const parseForwardPorts = (listed, sandboxId, owner) => parseForwardNames(listed, sandboxId, owner).flatMap((name) => {
     const port = Number(FORWARD_NAME.exec(name)?.[2]);
     return Number.isInteger(port) ? [port] : [];
 });
-export const forwardedPorts = (mutagen, sandboxId) => parseForwardPorts(listSessionNames(mutagen, "forward"), sandboxId);
-const orphanForwardSessions = (mutagen, keptSandboxIds) => parseOrphanForwardNames(listSessionNames(mutagen, "forward"), keptSandboxIds);
+export const forwardedPorts = (mutagen, sandboxId) => {
+    const listed = listSessionNames(mutagen, "forward");
+    return listed === undefined ? undefined : parseForwardPorts(listed, sandboxId, sessionOwner());
+};
 export const mutagenForwardArgs = (args) => [
     "forward",
     "create",
     "--name",
     args.name,
+    ...labelArgs(args.labels),
     `tcp:127.0.0.1:${args.port}`,
     mutagenForwardUrl(args.remote, `tcp:${args.host.includes(":") ? `[${args.host}]` : args.host}:${args.port}`),
 ];
 export const syncMode = (pairing) => isProjectPairing(pairing) && projectDirection(pairing) === "to-sandbox" ? "one-way-safe" : "two-way-safe";
-export const sessionSpec = (pairing, symlinks) => ({
-    name: sessionName(pairing.sandboxId),
+export const sessionSpec = (pairing, symlinks, owner) => ({
+    name: sessionName(pairingKey(pairing)),
     localDir: pairing.localDir,
     remote: pairingEndpoint(pairing),
     remoteDir: pairingRemoteDir(pairing),
@@ -72,9 +160,10 @@ export const sessionSpec = (pairing, symlinks) => ({
     from: "local",
     symlinks,
     pollSeconds: SANDBOX_POLL_SECONDS,
+    ...(owner === undefined ? {} : { labels: sessionLabels(pairing.sandboxId, "sync", owner) }),
 });
-const backupSpec = (pairing, symlinks) => ({
-    name: backupSessionName(pairing.sandboxId),
+const backupSpec = (pairing, symlinks, owner) => ({
+    name: backupSessionName(pairingKey(pairing)),
     localDir: join(pairing.localDir, STATE_DIR),
     remote: pairingEndpoint(pairing),
     remoteDir: `${WORKSPACE_ROOT}/${STATE_DIR}`,
@@ -83,6 +172,7 @@ const backupSpec = (pairing, symlinks) => ({
     from: "sandbox",
     symlinks,
     pollSeconds: BACKUP_POLL_SECONDS,
+    ...(owner === undefined ? {} : { labels: sessionLabels(pairing.sandboxId, "state", owner) }),
 });
 const SANDBOX_POLL_SECONDS = 2;
 const SANDBOX_WATCH_MODE = "force-poll";
@@ -99,6 +189,7 @@ export const mutagenCreateArgs = (spec, paused) => {
         spec.name,
         "--sync-mode",
         spec.mode,
+        ...labelArgs(spec.labels),
         "--symlink-mode",
         spec.symlinks,
         ...(paused ? ["--paused"] : []),
@@ -117,8 +208,18 @@ export const liveProtocol = (end) => end.protocol ?? (end.host === undefined ? "
 const readSessions = (mutagen, name) => listSessions(mutagen, [name]);
 export const readAllSessions = (mutagen) => listSessions(mutagen, []);
 const listSessions = (mutagen, names) => {
-    const result = spawnSync(mutagen, ["sync", "list", "--template", "{{json .}}", ...names], { encoding: "utf8", windowsHide: true });
-    return result.status === 0 ? (JSON.parse(result.stdout) ?? []) : [];
+    const listed = listCall(mutagen, ["sync", "list", "--template", "{{json .}}"]);
+    if (listed === undefined) {
+        return undefined;
+    }
+    let sessions;
+    try {
+        sessions = JSON.parse(listed) ?? [];
+    }
+    catch {
+        return undefined;
+    }
+    return names.length === 0 ? sessions : sessions.filter((session) => session.name !== undefined && names.includes(session.name));
 };
 export const sessionsByName = (sessions) => {
     const byName = new Map();
@@ -168,11 +269,15 @@ const conflictedPath = (conflict) => {
     };
 };
 export const readSessionConflicts = (mutagen, name) => {
-    const session = readSessions(mutagen, name)[0];
+    const sessions = readSessions(mutagen, name);
+    if (sessions === undefined) {
+        return "unanswered";
+    }
+    const session = sessions[0];
     return session === undefined ? undefined : { ignores: session.ignore.paths ?? [], conflicts: (session.conflicts ?? []).map(conflictedPath) };
 };
 export const flushSession = async (mutagen, name) => {
-    await runProcess(mutagen, ["sync", "flush", "--skip-wait", name]);
+    await runProcess(mutagen, ["sync", "flush", "--skip-wait", name], { timeoutMs: MUTAGEN_CALL_TIMEOUT_MS });
 };
 export const conflictsFrom = (session) => {
     const listed = session.conflicts ?? [];
@@ -180,7 +285,7 @@ export const conflictsFrom = (session) => {
     const count = listed.length + (Number.isFinite(excluded) ? excluded : 0);
     return count === 0 ? undefined : { count, paths: listed.slice(0, CONFLICT_PATHS_MAX).map(conflictedPath) };
 };
-export const readSessionState = (mutagen, name) => sessionStateOf(readSessions(mutagen, name)[0]);
+export const readSessionState = (mutagen, name) => sessionStateOf(readSessions(mutagen, name)?.[0]);
 export const sessionStateOf = (session) => {
     if (session === undefined) {
         return { exists: false };
@@ -195,41 +300,50 @@ export const sessionStateOf = (session) => {
     };
 };
 export const existingSyncSessions = (mutagen, names) => {
-    const listed = new Set(oursIn(listSessionNames(mutagen, "sync"), SESSION_PREFIX));
-    return names.filter((name) => listed.has(name));
+    const listed = listSessionNames(mutagen, "sync");
+    if (listed === undefined) {
+        return undefined;
+    }
+    const held = new Set(oursIn(listed, SESSION_PREFIX, sessionOwner()));
+    return names.filter((name) => held.has(name));
 };
 export const pauseRunningSync = (mutagen, pairing) => {
     if (pairing.mode !== "sync") {
         return false;
     }
     const names = existingSyncSessions(mutagen, syncSessionNames(pairing));
-    if (names.every((name) => readSessionState(mutagen, name).paused === true)) {
+    if (names === undefined || names.every((name) => readSessionState(mutagen, name).paused === true)) {
         return false;
     }
-    const result = spawnSync(mutagen, ["sync", "pause", ...names], { stdio: "ignore", windowsHide: true });
+    const result = spawnSync(mutagen, ["sync", "pause", ...names], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
     return result.status === 0;
 };
 export const pauseUnreachableSync = pauseRunningSync;
 export const resumeSwapPausedSync = (mutagen, pairing) => {
     const names = existingSyncSessions(mutagen, syncSessionNames(pairing));
-    if (names.length === 0) {
+    if (names === undefined || names.length === 0) {
         return false;
     }
-    return spawnSync(mutagen, ["sync", "resume", ...names], { stdio: "ignore", windowsHide: true }).status === 0;
+    return spawnSync(mutagen, ["sync", "resume", ...names], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS }).status === 0;
 };
 export const resumeAutoPausedSync = (mutagen, pairing) => {
     if (pairing.mode !== "sync" || pairing.fileSyncAutoPaused !== true) {
         return false;
     }
     const names = existingSyncSessions(mutagen, syncSessionNames(pairing));
-    if (names.length === 0) {
+    if (names === undefined || names.length === 0) {
         return false;
     }
-    const result = spawnSync(mutagen, ["sync", "resume", ...names], { stdio: "ignore", windowsHide: true });
+    const result = spawnSync(mutagen, ["sync", "resume", ...names], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
     return result.status === 0;
 };
+export const resumeWatcherPausedSync = (mutagen, pairing) => resumeSwapPausedSync(mutagen, pairing);
 export const sameEnds = (session, spec) => {
-    const local = { protocol: "local", host: undefined, path: spec.localDir };
+    const local = {
+        protocol: "local",
+        host: undefined,
+        path: spec.localDir,
+    };
     const remote = { ...liveIdentity(spec.remote), path: spec.remoteDir };
     const [alpha, beta] = spec.from === "local" ? [local, remote] : [remote, local];
     const matches = (live, wanted) => live.path === wanted.path && live.host === wanted.host && liveProtocol(live) === wanted.protocol;
@@ -248,41 +362,83 @@ export const sessionMatchesSpec = (session, spec) => {
         (session.ignore.paths ?? []).join("\n") === spec.ignores.join("\n") &&
         (session.symlink?.mode ?? "portable") === spec.symlinks);
 };
-export const ensureSyncSession = async (mutagen, pairing, log) => {
+export const relabelBudget = (count) => {
+    let left = count;
+    return {
+        take: () => {
+            if (left <= 0) {
+                return false;
+            }
+            left -= 1;
+            return true;
+        },
+    };
+};
+const NO_RELABELS = { take: () => false };
+export const ensureSyncSession = async (mutagen, pairing, log, relabels = NO_RELABELS) => {
     if (pairing.mode !== "sync" || pairing.localDir === undefined) {
         return true;
     }
     const held = { ...pairing, localDir: pairing.localDir };
+    if (pairing.adoptFolder === true && !(await adoptBeforeFirstSession(mutagen, held, log))) {
+        return false;
+    }
     const symlinks = await deviceSymlinks();
     if (symlinks.refusal !== undefined) {
-        log(`${pairing.sandboxId}: this device cannot create symbolic links (${symlinks.refusal}), so its file sync leaves them out instead of failing on each one every cycle. On Windows, turning on Developer Mode lets the next start of this agent carry them.`);
+        log(`${pairingKey(pairing)}: this device cannot create symbolic links (${symlinks.refusal}), so its file sync leaves them out instead of failing on each one every cycle. On Windows, turning on Developer Mode lets the next start of this agent carry them.`);
     }
     let converged = true;
     const answers = transportAnswers(pairing);
-    for (const spec of sessionSpecs(held, symlinks.mode)) {
-        converged = (await convergeSession(mutagen, spec, log, answers)) && converged;
+    for (const spec of sessionSpecs(held, symlinks.mode, sessionOwner())) {
+        converged = (await convergeSession(mutagen, spec, log, answers, relabels)) && converged;
     }
     retireStrayBackup(mutagen, pairing, log);
     return converged;
 };
-export const sessionSpecs = (pairing, symlinks) => isProjectPairing(pairing) ? [sessionSpec(pairing, symlinks)] : [sessionSpec(pairing, symlinks), backupSpec(pairing, symlinks)];
-export const strayBackupSessions = (pairing, live) => isProjectPairing(pairing) ? live.filter((name) => name === backupSessionName(pairing.sandboxId)) : [];
+const adoptBeforeFirstSession = async (mutagen, pairing, log) => {
+    const key = pairingKey(pairing);
+    const existing = existingSyncSessions(mutagen, [sessionName(key)]);
+    if (existing === undefined) {
+        return false;
+    }
+    if (existing.length === 0) {
+        try {
+            await adoptFolder({
+                localDir: pairing.localDir,
+                sandbox: sandboxCopy(realProjectRunner, projectShell(pairingEndpoint(pairing), mutagenSshPath(process.platform, process.env["MUTAGEN_SSH_PATH"])), pairingRemoteDir(pairing)),
+                ignores: ignoresFor(pairing),
+                log: (line) => log(`${key}: ${line}`),
+            });
+        }
+        catch (error) {
+            log(`${key}: ${pairing.localDir} could not be compared with the sandbox's copy (${errorMessage(error)}), so its file sync waits rather than start over two copies that disagree. Retrying later.`);
+            return false;
+        }
+    }
+    await clearAdoptFolder(key);
+    return true;
+};
+export const sessionSpecs = (pairing, symlinks, owner) => isProjectPairing(pairing)
+    ? [sessionSpec(pairing, symlinks, owner)]
+    : [sessionSpec(pairing, symlinks, owner), backupSpec(pairing, symlinks, owner)];
+export const strayBackupSessions = (pairing, live) => isProjectPairing(pairing) ? live.filter((name) => name === backupSessionName(pairingKey(pairing))) : [];
 const retireStrayBackup = (mutagen, pairing, log) => {
-    const stray = strayBackupSessions(pairing, existingSyncSessions(mutagen, [backupSessionName(pairing.sandboxId)]));
+    const live = existingSyncSessions(mutagen, [backupSessionName(pairingKey(pairing))]);
+    const stray = live === undefined ? [] : strayBackupSessions(pairing, live);
     if (stray.length === 0) {
         return;
     }
-    spawnSync(mutagen, ["sync", "terminate", ...stray], { stdio: "ignore", windowsHide: true });
-    log(`${pairing.sandboxId}: its folder is a project of yours, which carries no copy of the sandbox's state; terminated the state backup that was writing one into it.`);
+    spawnSync(mutagen, ["sync", "terminate", ...stray], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
+    log(`${pairingKey(pairing)}: its folder is a project of yours, which carries no copy of the sandbox's state; terminated the state backup that was writing one into it.`);
 };
 export const surplusSessions = (sessions) => sessions.slice(1).flatMap((session) => (session.identifier === undefined ? [] : [session.identifier]));
 const retireSurplus = (mutagen, name, log) => {
     const sessions = readSessions(mutagen, name);
-    const surplus = surplusSessions(sessions);
-    if (surplus.length === 0) {
+    const surplus = sessions === undefined ? [] : surplusSessions(sessions);
+    if (sessions === undefined || surplus.length === 0) {
         return sessions;
     }
-    spawnSync(mutagen, ["sync", "terminate", ...surplus], { stdio: "ignore", windowsHide: true });
+    spawnSync(mutagen, ["sync", "terminate", ...surplus], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
     log(`${name}: ${sessions.length} sync sessions shared this name and flagged each other's writes as conflicts; kept the oldest and terminated the rest.`);
     return readSessions(mutagen, name);
 };
@@ -291,7 +447,10 @@ export const convergePlan = (sessions, spec) => {
         return "create";
     }
     const only = sessions.length === 1 ? sessions[0] : undefined;
-    return only !== undefined && sessionMatchesSpec(only, spec) ? "keep" : "replace";
+    if (only === undefined || !sessionMatchesSpec(only, spec)) {
+        return "replace";
+    }
+    return spec.labels !== undefined && ownershipOf(only.labels, spec.labels.owner) === "unlabelled" ? "relabel" : "keep";
 };
 export const settlesFirst = (spec, live) => spec.mode === "two-way-safe" && live.every((session) => liveMode(session) === "two-way-safe");
 const readyForReplacement = async (mutagen, spec, live, log) => {
@@ -300,6 +459,9 @@ const readyForReplacement = async (mutagen, spec, live, log) => {
     }
     await flushSession(mutagen, spec.name);
     const held = readSessionConflicts(mutagen, spec.name);
+    if (held === "unanswered") {
+        return false;
+    }
     const cleared = held === undefined || held.conflicts.length === 0
         ? { standing: 0 }
         : await clearConflictResidue({ root: spec.localDir, conflicts: held.conflicts, ignores: held.ignores, log });
@@ -330,12 +492,31 @@ export const transportAnswers = (pairing) => {
         ? async () => await dockerEndpointAnswers(endpoint.container, pairing.sandboxUrl)
         : async () => await sshTransportAnswers(mutagenSshPath(process.platform, process.env["MUTAGEN_SSH_PATH"]), endpoint.alias);
 };
-const convergeSession = async (mutagen, spec, log, answers) => {
+export const terminationTargets = (sessions, name) => sessions.length > 0 && sessions.every((session) => session.identifier !== undefined)
+    ? sessions.flatMap((session) => session.identifier ?? [])
+    : [name];
+const convergeSession = async (mutagen, spec, log, answers, relabels) => {
+    const listed = readSessions(mutagen, spec.name);
+    if (listed === undefined) {
+        log(`${spec.name}: Mutagen did not answer a listing, so this session is left as it is this pass. Retrying later.`);
+        return false;
+    }
+    const owner = spec.labels?.owner;
+    if (owner !== undefined && listed.some((session) => ownershipOf(session.labels, owner) === "theirs")) {
+        log(`${spec.name}: a session of this name belongs to another owner (${OWNER_LABEL} says so), so this one is neither replaced nor made beside it.`);
+        return false;
+    }
     const sessions = retireSurplus(mutagen, spec.name, log);
+    if (sessions === undefined) {
+        return false;
+    }
     const plan = convergePlan(sessions, spec);
     if (plan === "keep") {
         return true;
     }
+    if (plan === "relabel" && !relabels.take()) {
+        return false;
+    }
     const live = sessions.length === 1 ? sessions[0] : undefined;
     if (sessions.length > 1) {
         log(`${spec.name}: ${sessions.length} sync sessions share this name, which conflict with each other; replacing them with one.`);
@@ -344,7 +525,7 @@ const convergeSession = async (mutagen, spec, log, answers) => {
         log(`${spec.name}: ${spec.remote.container} is not running on this machine's Docker engine as this sandbox, so no file sync is made into it. Retrying later.`);
         return false;
     }
-    if (plan === "replace") {
+    if (plan === "replace" || plan === "relabel") {
         if (!(await answers())) {
             log(`${spec.name}: the sandbox is not answering, so its existing file sync is left running as it is rather than terminated for a replacement that cannot be created. Retrying later.`);
             return false;
@@ -352,8 +533,14 @@ const convergeSession = async (mutagen, spec, log, answers) => {
         if (!(await readyForReplacement(mutagen, spec, sessions, log))) {
             return false;
         }
-        log(`${spec.name}: the running sync session does not match this build's rules (its ignores, its folder, which way it syncs, or what it does with symbolic links): recreating it so they apply, as ${spec.mode}. This starts the comparison from scratch.`);
-        spawnSync(mutagen, ["sync", "terminate", spec.name], { stdio: "ignore", windowsHide: true });
+        log(plan === "relabel"
+            ? `${spec.name}: made before this agent labelled its sessions, and Mutagen cannot label a session that exists: recreating it with this machine's ownership labels, as ${spec.mode}. Both sides are rescanned; nothing that already matches is copied.`
+            : `${spec.name}: the running sync session does not match this build's rules (its ignores, its folder, which way it syncs, or what it does with symbolic links): recreating it so they apply, as ${spec.mode}. This starts the comparison from scratch.`);
+        spawnSync(mutagen, ["sync", "terminate", ...terminationTargets(sessions, spec.name)], {
+            stdio: "ignore",
+            windowsHide: true,
+            timeout: MUTAGEN_CALL_TIMEOUT_MS,
+        });
     }
     await runMutagenAsync(mutagen, mutagenCreateArgs(spec, live?.paused === true), log);
     return true;
@@ -367,47 +554,61 @@ export const healDerivedConflicts = async (mutagen, pairing, log, asked = false)
     if (!asked && (pairing.autoHealOff === true || pairing.fileSyncAutoPaused === true)) {
         return idle;
     }
-    const held = readSessionConflicts(mutagen, sessionName(pairing.sandboxId));
-    if (held === undefined || held.conflicts.length === 0) {
+    const held = readSessionConflicts(mutagen, sessionName(pairingKey(pairing)));
+    if (held === undefined || held === "unanswered" || held.conflicts.length === 0) {
         return idle;
     }
     const outcome = await clearConflictResidue({ root: pairing.localDir, conflicts: held.conflicts, ignores: held.ignores, log });
     if (outcome.removed.length > 0) {
-        await flushSession(mutagen, sessionName(pairing.sandboxId));
+        await flushSession(mutagen, sessionName(pairingKey(pairing)));
     }
     return outcome;
 };
-export const retireOrphanSessions = (mutagen, pairings, log) => {
-    const ids = pairings.map((pairing) => pairing.sandboxId);
-    const sessions = parseOrphanSyncNames(listSessionNames(mutagen, "sync"), pairings.flatMap((pairing) => syncSessionNames(pairing)));
-    if (sessions.length > 0) {
-        spawnSync(mutagen, ["sync", "terminate", ...sessions], { stdio: "ignore", windowsHide: true });
+export const retireOrphanSessions = (mutagen, pairings, log, owner = sessionOwner()) => {
+    const listedSync = listSessionNames(mutagen, "sync");
+    const sessions = listedSync === undefined
+        ? []
+        : parseOrphanSyncNames(listedSync, pairings.flatMap((pairing) => syncSessionNames(pairing)), owner);
+    if (listedSync !== undefined && sessions.length > 0) {
+        spawnSync(mutagen, ["sync", "terminate", ...terminateTargetsIn(listedSync, sessions, SESSION_PREFIX, owner)], {
+            stdio: "ignore",
+            windowsHide: true,
+            timeout: MUTAGEN_CALL_TIMEOUT_MS,
+        });
         log(`retired ${plural(sessions.length, "file-sync session")} belonging to sandboxes this machine no longer pairs.`);
     }
-    const forwards = orphanForwardSessions(mutagen, ids);
-    if (forwards.length > 0) {
-        spawnSync(mutagen, ["forward", "terminate", ...forwards], { stdio: "ignore", windowsHide: true });
+    const listedForwards = listSessionNames(mutagen, "forward");
+    const forwards = listedForwards === undefined
+        ? []
+        : parseOrphanForwardNames(listedForwards, pairings.map((pairing) => pairing.sandboxId), owner);
+    if (listedForwards !== undefined && forwards.length > 0) {
+        spawnSync(mutagen, ["forward", "terminate", ...terminateTargetsIn(listedForwards, forwards, FORWARD_PREFIX, owner)], {
+            stdio: "ignore",
+            windowsHide: true,
+            timeout: MUTAGEN_CALL_TIMEOUT_MS,
+        });
         log(`released ${plural(forwards.length, "port forward")} left holding localhost for sandboxes this machine no longer pairs.`);
     }
 };
 const installedVersion = (binary, versionArgs) => {
-    const result = spawnSync(binary, versionArgs, { encoding: "utf8", windowsHide: true });
+    const result = spawnSync(binary, versionArgs, { encoding: "utf8", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
     if (result.error !== undefined || result.status !== 0) {
         return undefined;
     }
     return /\d+\.\d+\.\d+/.exec(result.stdout)?.[0];
 };
 const extractTarball = (tarball) => {
-    const extract = spawnSync("tar", ["-xzf", tarball, "-C", binDir], { stdio: "inherit", windowsHide: true });
+    const extract = spawnSync("tar", ["-xzf", tarball, "-C", binDir], { stdio: "inherit", windowsHide: true, timeout: 2 * 60_000 });
     if (extract.status !== 0) {
         throw new Error(`failed to extract ${tarball}: tar's own reason is above (no \`tar\` on PATH, or a file it must replace is in use)`);
     }
 };
+const PATH_LOOKUP_TIMEOUT_MS = 10_000;
 const resolveOnPath = (command) => {
     const whereExe = join(process.env["SystemRoot"] ?? "C:\\Windows", "System32", "where.exe");
     const found = process.platform === "win32"
-        ? spawnSync(whereExe, [command], { encoding: "utf8", windowsHide: true })
-        : spawnSync("sh", ["-c", `command -v ${command}`], { encoding: "utf8" });
+        ? spawnSync(whereExe, [command], { encoding: "utf8", windowsHide: true, timeout: PATH_LOOKUP_TIMEOUT_MS })
+        : spawnSync("sh", ["-c", `command -v ${command}`], { encoding: "utf8", timeout: PATH_LOOKUP_TIMEOUT_MS });
     const first = found.status === 0 ? found.stdout.split("\n")[0]?.trim() : undefined;
     return first === undefined || first === "" || !existsSync(first) ? undefined : first;
 };
@@ -416,16 +617,30 @@ export const isOwnMutagen = (mutagen, own = ownMutagenPath(), platform = process
     const fold = (path) => (platform === "win32" ? path.replaceAll("/", "\\").toLowerCase() : path);
     return fold(mutagen) === fold(own);
 };
+export const userMutagenOnPath = () => {
+    const found = resolveOnPath("mutagen");
+    return found === undefined || isOwnMutagen(found) ? undefined : found;
+};
 export const ensureMutagen = async () => {
-    const own = resolveOnPath("mutagen");
-    if (own !== undefined && installedVersion(own, ["version"]) !== undefined) {
-        return own;
-    }
     const dest = ownMutagenPath();
     if (installedVersion(dest, ["version"]) === MUTAGEN_VERSION) {
         return dest;
     }
-    spawnSync(dest, ["daemon", "stop"], { stdio: "ignore", windowsHide: true });
+    try {
+        await installPinnedMutagen(dest);
+        return dest;
+    }
+    catch (error) {
+        const onPath = resolveOnPath("mutagen");
+        if (onPath !== undefined && installedVersion(onPath, ["version"]) !== undefined) {
+            daemonLog?.(`this agent's own Mutagen ${MUTAGEN_VERSION} could not be fetched (${errorMessage(error)}); using ${onPath} until it can.`);
+            return onPath;
+        }
+        throw error;
+    }
+};
+const installPinnedMutagen = async (dest) => {
+    spawnSync(dest, ["daemon", "stop"], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
     const tarball = join(binDir, "mutagen.tar.gz");
     await download(`https://github.com/mutagen-io/mutagen/releases/download/v${MUTAGEN_VERSION}/mutagen_${osToken()}_${archToken()}_v${MUTAGEN_VERSION}.tar.gz`, tarball);
     const displaced = `${dest}.old`;
@@ -434,10 +649,9 @@ export const ensureMutagen = async () => {
     await chmod(dest, 0o755);
     await rm(displaced, { force: true }).catch(() => undefined);
     await rm(tarball, { force: true }).catch(() => undefined);
-    return dest;
 };
 export const runMutagenAsync = async (mutagen, args, log) => {
-    const result = await runProcess(mutagen, args);
+    const result = await runProcess(mutagen, args, { timeoutMs: MUTAGEN_CREATE_TIMEOUT_MS });
     const said = `${result.stdout}${result.stderr}`.trim();
     if (result.status === 0) {
         return;
@@ -448,7 +662,7 @@ export const runMutagenAsync = async (mutagen, args, log) => {
     throw new Error(`mutagen ${args[0] ?? ""} exited with code ${result.status}`);
 };
 export const runMutagen = (mutagen, args) => {
-    const result = spawnSync(mutagen, args, { stdio: "inherit", windowsHide: true });
+    const result = spawnSync(mutagen, args, { stdio: "inherit", windowsHide: true, timeout: MUTAGEN_CREATE_TIMEOUT_MS });
     if (result.error !== undefined) {
         throw result.error;
     }
@@ -468,7 +682,7 @@ export const registerMutagenAutostart = (mutagen, launcher, log) => {
             runMutagen(mutagen, ["daemon", "register"]);
             return;
         }
-        spawnSync(mutagen, ["daemon", "unregister"], { stdio: "ignore", windowsHide: true });
+        spawnSync(mutagen, ["daemon", "unregister"], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
         setWindowsRunValue(MUTAGEN_RUN_VALUE, quotedCommandLine(stubCommand(stub, mutagenDaemonLogPath, [mutagen, "daemon", "start"])));
     }
     catch (error) {
@@ -480,7 +694,7 @@ export const unregisterMutagenAutostart = (mutagen) => {
         clearWindowsRunValue(MUTAGEN_RUN_VALUE);
     }
     if (process.platform !== "linux") {
-        spawnSync(mutagen, ["daemon", "unregister"], { stdio: "ignore", windowsHide: true });
+        spawnSync(mutagen, ["daemon", "unregister"], { stdio: "ignore", windowsHide: true, timeout: MUTAGEN_CALL_TIMEOUT_MS });
     }
 };
 //# sourceMappingURL=mutagen.js.map