@overdeck/desktop 0.45.21 → 0.45.23

package/server/{state-home-DixkE-up.js → state-home-CIGjwNfJ.js}

@@ -1,7 +1,7 @@
 import { n as __esmMin } from "./rolldown-runtime-DNCzzKnI.js";
-import { Zn as resolveInfraRepo, bn as projectKey, cn as STATE_BRANCH_PATHS, dn as init_state_plane, ei as getOverdeckHome, ti as init_paths, yn as init_project_key, zn as init_projects } from "./config-yaml-Ciyp2mYe.js";
+import { Br as getOverdeckHome, Kt as STATE_BRANCH_PATHS, Ln as resolveInfraRepo, Tn as init_projects, Vr as init_paths, Yt as init_state_plane, an as init_project_key, on as projectKey } from "./config-yaml-DvyMuOle.js";
 import { dirname, join } from "node:path";
-import { existsSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { mkdir, rm } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
@@ -14,13 +14,15 @@ import { promisify } from "node:util";
 * An unmarked branch is an in-progress migration and continues using legacy
 * project-root state paths.
 */
-async function git(repoPath, args) {
+async function git(repoPath, args, signal) {
+	signal?.throwIfAborted();
 	const { stdout } = await execFileAsync("git", args, {
 		cwd: repoPath,
 		encoding: "utf8",
 		maxBuffer: 16 * 1024 * 1024,
 		timeout: 15e3,
-		killSignal: "SIGTERM"
+		killSignal: "SIGTERM",
+		signal
 	});
 	return stdout.trim();
 }
@@ -38,28 +40,49 @@ function parseMigrationCompleteMarker(value) {
 	if (!Number.isInteger(marker.version) || (marker.version ?? 0) < 1) return null;
 	return marker;
 }
-async function remoteStateTip(repoPath) {
-	const sha = (await git(repoPath, [
+function readMigrationCompleteMarker(path) {
+	if (!existsSync(path)) return null;
+	try {
+		return parseMigrationCompleteMarker(JSON.parse(readFileSync(path, "utf8")));
+	} catch {
+		return null;
+	}
+}
+async function remoteStateTip(repoPath, signal, runGit = git) {
+	const sha = (await runGit(repoPath, [
 		"ls-remote",
 		"--heads",
 		"origin",
 		`refs/heads/${STATE_BRANCH}`
-	])).split(/\s+/)[0];
+	], signal)).split(/\s+/)[0];
 	return isSha(sha) ? sha : null;
 }
-async function markerAtRemoteTip(repoPath, tip) {
-	await git(repoPath, [
-		"fetch",
-		"--quiet",
-		"origin",
-		`refs/heads/${STATE_BRANCH}:refs/remotes/origin/${STATE_BRANCH}`
-	]);
-	if (await git(repoPath, ["rev-parse", `refs/remotes/origin/overdeck-state`]) !== tip) return null;
+async function markerAtRemoteTip(repoPath, initialTip, signal, runGit = git) {
+	let tip = initialTip;
+	for (let attempt = 0; attempt < 3; attempt += 1) {
+		await runGit(repoPath, [
+			"fetch",
+			"--quiet",
+			"origin",
+			`refs/heads/${STATE_BRANCH}:refs/remotes/origin/${STATE_BRANCH}`
+		], signal);
+		const fetchedTip = await runGit(repoPath, ["rev-parse", `refs/remotes/origin/${STATE_BRANCH}`], signal);
+		if (!isSha(fetchedTip)) throw new Error(`Invalid origin/${STATE_BRANCH} tip: ${fetchedTip}`);
+		if (fetchedTip === tip || attempt === 2) {
+			tip = fetchedTip;
+			break;
+		}
+		tip = fetchedTip;
+	}
 	let raw;
 	try {
-		raw = await git(repoPath, ["show", `${tip}:${MIGRATION_COMPLETE_MARKER}`]);
+		raw = await runGit(repoPath, ["show", `${tip}:${MIGRATION_COMPLETE_MARKER}`], signal);
 	} catch {
-		return null;
+		signal?.throwIfAborted();
+		return {
+			marker: null,
+			tip
+		};
 	}
 	let marker;
 	try {
@@ -67,42 +90,77 @@ async function markerAtRemoteTip(repoPath, tip) {
 	} catch {
 		marker = null;
 	}
-	if (!marker) return null;
-	return await git(repoPath, [
-		"merge-base",
-		"--is-ancestor",
-		marker.stateBranchSha,
+	if (!marker) return {
+		marker: null,
+		tip
+	};
+	return {
+		marker: await runGit(repoPath, [
+			"merge-base",
+			"--is-ancestor",
+			marker.stateBranchSha,
+			tip
+		], signal).then(() => true).catch(() => {
+			signal?.throwIfAborted();
+			return false;
+		}) ? marker : null,
 		tip
-	]).then(() => true).catch(() => false) ? marker : null;
+	};
 }
-async function inspectStateMigration(project) {
+async function inspectStateMigration(project, options = {}) {
 	const { repoPath } = resolveInfraRepo(project);
-	let tip;
+	const cached = migrationCache.get(repoPath);
+	const runGit = options.git ?? git;
 	try {
-		tip = await remoteStateTip(repoPath);
+		const listedTip = await remoteStateTip(repoPath, options.signal, runGit);
+		if (cached?.remoteTip === listedTip) return {
+			migrated: cached.migrated,
+			migrationInProgress: listedTip !== null && !cached.migrated,
+			remoteTip: listedTip
+		};
+		if (listedTip === null) {
+			migrationCache.set(repoPath, {
+				remoteTip: null,
+				migrated: false
+			});
+			return {
+				migrated: false,
+				migrationInProgress: false,
+				remoteTip: null
+			};
+		}
+		const remote = await markerAtRemoteTip(repoPath, listedTip, options.signal, runGit);
+		const migrated = remote.marker !== null;
+		migrationCache.set(repoPath, {
+			remoteTip: remote.tip,
+			migrated
+		});
+		return {
+			migrated,
+			migrationInProgress: !migrated,
+			remoteTip: remote.tip
+		};
 	} catch {
+		options.signal?.throwIfAborted();
+		if (cached?.migrated) return {
+			migrated: true,
+			migrationInProgress: false,
+			remoteTip: cached.remoteTip,
+			fallback: "cache"
+		};
+		if (readMigrationCompleteMarker(join(stateWorktreePath(project, options), "migration-complete.json"))) return {
+			migrated: true,
+			migrationInProgress: false,
+			remoteTip: null,
+			fallback: "local"
+		};
 		return {
 			migrated: false,
 			migrationInProgress: false,
-			remoteTip: null
+			remoteTip: null,
+			remoteCheckFailed: true
 		};
 	}
-	const cached = migrationCache.get(repoPath);
-	if (cached?.remoteTip === tip) return {
-		migrated: cached.migrated,
-		migrationInProgress: tip !== null && !cached.migrated,
-		remoteTip: tip
-	};
-	const migrated = tip !== null && await markerAtRemoteTip(repoPath, tip) !== null;
-	migrationCache.set(repoPath, {
-		remoteTip: tip,
-		migrated
-	});
-	return {
-		migrated,
-		migrationInProgress: tip !== null && !migrated,
-		remoteTip: tip
-	};
 }
 async function isStateMigrated(project) {
 	return (await inspectStateMigration(project)).migrated;
@@ -112,14 +170,18 @@ async function findRecreatedLegacyStatePaths(project) {
 	const legacyStateRoot = project.path;
 	return STATE_BRANCH_PATHS.map((statePath) => join(legacyStateRoot, ".pan", statePath.slice(0, -1))).filter(existsSync);
 }
-async function addStateWorktree(repoPath, path) {
+async function addStateWorktree(repoPath, path, signal) {
+	signal?.throwIfAborted();
 	await mkdir(dirname(path), { recursive: true });
 	await git(repoPath, await git(repoPath, [
 		"show-ref",
 		"--verify",
 		"--quiet",
 		`refs/heads/overdeck-state`
-	]).then(() => true, () => false) ? [
+	], signal).then(() => true).catch(() => {
+		signal?.throwIfAborted();
+		return false;
+	}) ? [
 		"worktree",
 		"add",
 		path,
@@ -132,18 +194,19 @@ async function addStateWorktree(repoPath, path) {
 		STATE_BRANCH,
 		path,
 		`origin/${STATE_BRANCH}`
-	]);
+	], signal);
 }
 async function ensureStateWorktree(project, options = {}) {
-	const migration = await inspectStateMigration(project);
+	const migration = await inspectStateMigration(project, options);
 	const path = stateWorktreePath(project, options);
 	if (!migration.migrated) return {
 		status: "legacy",
-		path
+		path,
+		detail: migration.remoteCheckFailed ? "The remote overdeck-state marker check failed transiently and no valid cached or local marker was available." : "The remote overdeck-state branch is reachable but does not contain a valid migration marker."
 	};
 	const { repoPath } = resolveInfraRepo(project);
 	if (!existsSync(path)) {
-		await addStateWorktree(repoPath, path);
+		await addStateWorktree(repoPath, path, options.signal);
 		return {
 			status: "created",
 			path
@@ -151,8 +214,9 @@ async function ensureStateWorktree(project, options = {}) {
 	}
 	let branch;
 	try {
-		branch = await git(path, ["branch", "--show-current"]);
+		branch = await git(path, ["branch", "--show-current"], options.signal);
 	} catch (error) {
+		options.signal?.throwIfAborted();
 		return {
 			status: "error",
 			path,
@@ -164,7 +228,7 @@ async function ensureStateWorktree(project, options = {}) {
 		path
 	};
 	try {
-		if (await git(path, ["status", "--porcelain"])) return {
+		if (await git(path, ["status", "--porcelain"], options.signal)) return {
 			status: "dirty",
 			path,
 			detail: "state worktree has uncommitted changes; refusing destructive repair"
@@ -173,17 +237,18 @@ async function ensureStateWorktree(project, options = {}) {
 			"worktree",
 			"remove",
 			path
-		]);
+		], options.signal);
 		await rm(path, {
 			recursive: true,
 			force: true
 		});
-		await addStateWorktree(repoPath, path);
+		await addStateWorktree(repoPath, path, options.signal);
 		return {
 			status: "recreated",
 			path
 		};
 	} catch (error) {
+		options.signal?.throwIfAborted();
 		return {
 			status: "error",
 			path,
@@ -208,4 +273,4 @@ var init_state_home = __esmMin((() => {
 //#endregion
 export { findRecreatedLegacyStatePaths as a, isStateMigrated as c, ensureStateWorktree as i, stateWorktreePath as l, STATE_BRANCH as n, init_state_home as o, clearStateMigrationCache as r, inspectStateMigration as s, MIGRATION_COMPLETE_MARKER as t };
 
-//# sourceMappingURL=state-home-DixkE-up.js.map
+//# sourceMappingURL=state-home-CIGjwNfJ.js.map