@openspecui/server 2.3.5 → 2.3.6

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { createServer as createServer$1 } from "node:net";
 import { serve } from "@hono/node-server";
-import { CliExecutor, CodeEditorThemeSchema, ConfigManager, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, GitConfigSchema, OpenSpecAdapter, OpenSpecWatcher, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalRendererEngineSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, sniffGlobalCli } from "@openspecui/core";
+import { CliExecutor, CodeEditorThemeSchema, ConfigManager, DASHBOARD_METRIC_KEYS, DashboardConfigSchema, GitConfigSchema, OpenSpecAdapter, OpenSpecWatcher, OpsxKernel, PtyClientMessageSchema, ReactiveContext, TerminalConfigSchema, TerminalRendererEngineSchema, getAllTools, getAvailableTools, getConfiguredTools, getDefaultCliCommandString, getDetectedProjectTools, getToolInitStates, getWatcherRuntimeStatus, initWatcherPool, isWatcherPoolInitialized, sniffGlobalCli, subscribeWatcherRuntimeStatus } from "@openspecui/core";
 import { fetchRequestHandler } from "@trpc/server/adapters/fetch";
 import { applyWSSHandler } from "@trpc/server/adapters/ws";
 import { Hono } from "hono";
@@ -928,6 +928,210 @@ async function loadDashboardOverview(ctx, reason = "dashboard-refresh") {
 	};
 }
 
+//#endregion
+//#region src/project-recovery-service.ts
+function normalizeWorktreeBranchName(defaultBranch) {
+	const normalized = defaultBranch.trim();
+	return /^[^/]+\/(.+)$/.exec(normalized)?.[1] ?? normalized;
+}
+function getGitDirArgs(gitDir, args) {
+	return [
+		"--git-dir",
+		gitDir,
+		...args
+	];
+}
+var ProjectRecoveryService = class {
+	emitter = new EventEmitter();
+	current = { state: "idle" };
+	projectDir;
+	gitWorktreeHandoff;
+	runGit;
+	doesPathExist;
+	canonicalPath;
+	cachedGitCommonDir = null;
+	cachedCanonicalProjectDir;
+	primeRepositoryMetadataPromise = null;
+	recoveryEpoch = 0;
+	unsubscribeWatcherRuntime;
+	constructor(options) {
+		this.emitter.setMaxListeners(200);
+		this.projectDir = resolve(options.projectDir);
+		this.gitWorktreeHandoff = options.gitWorktreeHandoff;
+		this.runGit = options.runGit ?? defaultRunGit;
+		this.doesPathExist = options.pathExists ?? pathExists;
+		this.canonicalPath = options.canonicalPath ?? canonicalGitPath;
+		this.cachedCanonicalProjectDir = this.projectDir;
+		this.unsubscribeWatcherRuntime = (options.subscribeWatcherRuntime ?? subscribeWatcherRuntimeStatus)((status) => {
+			this.handleWatcherRuntimeStatus(status);
+		}, { emitCurrent: true });
+		this.primeRepositoryMetadata();
+	}
+	getCurrent() {
+		return this.current;
+	}
+	subscribe(listener, options = {}) {
+		this.emitter.on("change", listener);
+		if (options.emitCurrent !== false) listener(this.current);
+		return () => {
+			this.emitter.off("change", listener);
+		};
+	}
+	dispose() {
+		this.unsubscribeWatcherRuntime();
+		this.emitter.removeAllListeners();
+	}
+	setStatus(next) {
+		if (JSON.stringify(this.current) === JSON.stringify(next)) return;
+		this.current = next;
+		this.emitter.emit("change", next);
+	}
+	handleWatcherRuntimeStatus(status) {
+		const residency = status?.projectResidency;
+		if (!residency || residency.state === "active") {
+			this.recoveryEpoch += 1;
+			this.setStatus({ state: "idle" });
+			this.primeRepositoryMetadata();
+			return;
+		}
+		if (this.hasHandledEviction(residency)) return;
+		const epoch = ++this.recoveryEpoch;
+		this.setStatus({
+			state: "evicted",
+			reason: residency.reason,
+			detectedAt: residency.detectedAt
+		});
+		this.resolveRecovery(residency, epoch);
+	}
+	hasHandledEviction(residency) {
+		switch (this.current.state) {
+			case "evicted":
+			case "resolving":
+			case "ready":
+			case "unavailable":
+			case "failed": return this.current.detectedAt === residency.detectedAt;
+			default: return false;
+		}
+	}
+	async resolveRecovery(residency, epoch) {
+		this.setStatus({
+			state: "resolving",
+			reason: residency.reason,
+			detectedAt: residency.detectedAt
+		});
+		if (this.cachedGitCommonDir === null) await this.primeRepositoryMetadata();
+		if (epoch !== this.recoveryEpoch) return;
+		const gitCommonDir = this.cachedGitCommonDir;
+		if (!gitCommonDir || !await this.doesPathExist(gitCommonDir)) {
+			this.setStatus({
+				state: "unavailable",
+				reason: residency.reason,
+				detectedAt: residency.detectedAt,
+				message: "Cached Git metadata is unavailable, so automatic recovery cannot resolve a fallback worktree."
+			});
+			return;
+		}
+		const targetPath = await this.resolveFallbackTargetPath(gitCommonDir);
+		if (epoch !== this.recoveryEpoch) return;
+		if (!targetPath) {
+			this.setStatus({
+				state: "unavailable",
+				reason: residency.reason,
+				detectedAt: residency.detectedAt,
+				message: "No existing default-branch worktree is available for automatic recovery. Restore the worktree manually or reopen the repo from a surviving worktree."
+			});
+			return;
+		}
+		if (!this.gitWorktreeHandoff) {
+			this.setStatus({
+				state: "unavailable",
+				reason: residency.reason,
+				detectedAt: residency.detectedAt,
+				message: "This runtime cannot spawn or reuse sibling worktree servers for automatic recovery."
+			});
+			return;
+		}
+		try {
+			const handoff = await this.gitWorktreeHandoff.ensureWorktreeServer({ targetPath });
+			if (epoch !== this.recoveryEpoch) return;
+			this.setStatus({
+				state: "ready",
+				reason: residency.reason,
+				detectedAt: residency.detectedAt,
+				handoff
+			});
+		} catch (error) {
+			if (epoch !== this.recoveryEpoch) return;
+			this.setStatus({
+				state: "failed",
+				reason: residency.reason,
+				detectedAt: residency.detectedAt,
+				message: error instanceof Error ? error.message : String(error)
+			});
+		}
+	}
+	async primeRepositoryMetadata() {
+		if (this.primeRepositoryMetadataPromise) return this.primeRepositoryMetadataPromise;
+		this.primeRepositoryMetadataPromise = (async () => {
+			this.cachedCanonicalProjectDir = await this.canonicalPath(this.projectDir);
+			this.cachedGitCommonDir = await this.resolveGitCommonDir();
+		})();
+		try {
+			await this.primeRepositoryMetadataPromise;
+		} catch {
+			this.cachedGitCommonDir = null;
+			this.cachedCanonicalProjectDir = this.projectDir;
+		} finally {
+			this.primeRepositoryMetadataPromise = null;
+		}
+	}
+	async resolveGitCommonDir() {
+		const result = await this.runGit(this.projectDir, ["rev-parse", "--git-common-dir"]);
+		const gitCommonDirRaw = result.ok ? result.stdout.trim() : "";
+		if (!gitCommonDirRaw) return null;
+		return resolve(this.projectDir, gitCommonDirRaw);
+	}
+	async resolveDefaultBranchName(gitCommonDir) {
+		const cwd = dirname(gitCommonDir);
+		const remoteHead = await this.runGit(cwd, getGitDirArgs(gitCommonDir, [
+			"symbolic-ref",
+			"--quiet",
+			"--short",
+			"refs/remotes/origin/HEAD"
+		]));
+		const remoteRef = remoteHead.stdout.trim();
+		if (remoteHead.ok && remoteRef) return normalizeWorktreeBranchName(remoteRef);
+		const localHead = await this.runGit(cwd, getGitDirArgs(gitCommonDir, [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		]));
+		const localRef = localHead.stdout.trim();
+		if (localHead.ok && localRef && localRef !== "HEAD") return normalizeWorktreeBranchName(localRef);
+		return "main";
+	}
+	async resolveFallbackTargetPath(gitCommonDir) {
+		const cwd = dirname(gitCommonDir);
+		const defaultBranchName = await this.resolveDefaultBranchName(gitCommonDir);
+		const worktreeListResult = await this.runGit(cwd, getGitDirArgs(gitCommonDir, [
+			"worktree",
+			"list",
+			"--porcelain"
+		]));
+		if (!worktreeListResult.ok) return null;
+		const parsedWorktrees = parseWorktreeList(worktreeListResult.stdout);
+		for (const worktree of parsedWorktrees) {
+			const targetPath = resolve(worktree.path);
+			const branchName = worktree.branchRef?.replace(/^refs\/heads\//, "") ?? null;
+			if (worktree.detached || branchName !== defaultBranchName) continue;
+			if (!await this.doesPathExist(targetPath)) continue;
+			if (await this.canonicalPath(targetPath) === this.cachedCanonicalProjectDir) continue;
+			return targetPath;
+		}
+		return null;
+	}
+};
+
 //#endregion
 //#region src/pty-manager.ts
 const DEFAULT_SCROLLBACK = 1e3;
@@ -2275,7 +2479,8 @@ function buildSystemStatus(ctx) {
 		watcherEnabled: runtime?.initialized ?? false,
 		watcherGeneration: runtime?.generation ?? 0,
 		watcherReinitializeCount: runtime?.reinitializeCount ?? 0,
-		watcherLastReinitializeReason: runtime?.lastReinitializeReason ?? null
+		watcherLastReinitializeReason: runtime?.lastReinitializeReason ?? null,
+		projectRecovery: ctx.projectRecoveryService.getCurrent()
 	};
 }
 /**
@@ -2989,13 +3194,24 @@ const systemRouter = router({
 	}),
 	subscribe: publicProcedure.subscription(({ ctx }) => {
 		return observable((emit) => {
-			emit.next(buildSystemStatus(ctx));
-			const timer = setInterval(() => {
+			const pushStatus = () => {
 				emit.next(buildSystemStatus(ctx));
+			};
+			pushStatus();
+			const unsubscribeWatcherRuntime = subscribeWatcherRuntimeStatus(() => {
+				pushStatus();
+			});
+			const unsubscribeProjectRecovery = ctx.projectRecoveryService.subscribe(() => {
+				pushStatus();
+			});
+			const timer = setInterval(() => {
+				pushStatus();
 			}, 3e3);
 			timer.unref();
 			return () => {
 				clearInterval(timer);
+				unsubscribeWatcherRuntime();
+				unsubscribeProjectRecovery();
 			};
 		});
 	})
@@ -3300,6 +3516,10 @@ function createServer(config) {
 		configManager,
 		projectDir: config.projectDir
 	}, reason), watcher);
+	const projectRecoveryService = new ProjectRecoveryService({
+		projectDir: config.projectDir,
+		gitWorktreeHandoff: config.gitWorktreeHandoff
+	});
 	const app = new Hono();
 	const corsOrigins = config.corsOrigins ?? ["http://localhost:5173", "http://localhost:3000"];
 	app.use("*", cors({
@@ -3327,6 +3547,7 @@ function createServer(config) {
 				kernel,
 				searchService,
 				dashboardOverviewService,
+				projectRecoveryService,
 				gitWorktreeHandoff: config.gitWorktreeHandoff,
 				watcher,
 				projectDir: config.projectDir
@@ -3340,6 +3561,7 @@ function createServer(config) {
 		kernel,
 		searchService,
 		dashboardOverviewService,
+		projectRecoveryService,
 		gitWorktreeHandoff: config.gitWorktreeHandoff,
 		watcher,
 		projectDir: config.projectDir
@@ -3352,6 +3574,7 @@ function createServer(config) {
 		kernel,
 		searchService,
 		dashboardOverviewService,
+		projectRecoveryService,
 		watcher,
 		createContext,
 		port: config.port ?? 3100
@@ -3400,6 +3623,7 @@ async function createWebSocketServer(server, httpServer, config) {
 			server.watcher?.stop();
 			server.searchService.dispose().catch(() => {});
 			server.dashboardOverviewService.dispose();
+			server.projectRecoveryService.dispose();
 		}
 	};
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@openspecui/server",
-  "version": "2.3.5",
+  "version": "2.3.6",
   "type": "module",
   "main": "dist/index.mjs",
   "exports": {