host-service: integration test suite + 3 v2 bug fixes

packages/host-service/package.json

@@ -42,6 +42,8 @@
 		"dev": "bun run src/serve.ts",
 		"build:host": "bun run build.ts",
 		"generate": "drizzle-kit generate",
+		"test": "bun test --pass-with-no-tests",
+		"test:integration": "bun test --pass-with-no-tests test/integration",
 		"typecheck": "tsc --noEmit --emitDeclarationOnly false"
 	},
 	"dependencies": {

packages/host-service/src/app.ts

@@ -6,7 +6,7 @@ import type { MiddlewareHandler } from "hono";
 import { Hono } from "hono";
 import { cors } from "hono/cors";
 import { createApiClient } from "./api";
-import { createDb } from "./db";
+import { createDb, type HostDb } from "./db";
 import { EventBus, registerEventBusRoute } from "./events";
 import type { ApiAuthProvider } from "./providers/auth";
 import type { HostAuthProvider } from "./providers/host-auth";
@@ -35,29 +35,46 @@ export interface CreateAppOptions {
 		credentials: GitCredentialProvider;
 		modelResolver: ModelProviderRuntimeResolver;
 	};
+	/**
+	 * Test-harness override hooks. Production never sets these — `createApp`
+	 * builds each subsystem itself when omitted. `db` is overridden so tests
+	 * can swap in `bun:sqlite` (better-sqlite3 isn't loadable under Bun;
+	 * prod uses it on bundled Node). `api`, `github`, `chatRuntime`, and
+	 * `chatService` are overridden to keep tests off the network and out of
+	 * mastra storage.
+	 */
+	db?: HostDb;
+	api?: ApiClient;
+	github?: () => Promise<Octokit>;
+	chatRuntime?: ChatRuntimeManager;
+	chatService?: ChatService;
 }
 
 export interface CreateAppResult {
 	app: Hono;
 	injectWebSocket: ReturnType<typeof createNodeWebSocket>["injectWebSocket"];
 	api: ApiClient;
+	dispose: () => Promise<void>;
 }
 
 export function createApp(options: CreateAppOptions): CreateAppResult {
 	const { config, providers } = options;
 
-	const api = createApiClient(config.cloudApiUrl, providers.auth);
-	const db = createDb(config.dbPath, config.migrationsFolder);
+	const api =
+		options.api ?? createApiClient(config.cloudApiUrl, providers.auth);
+	const db = options.db ?? createDb(config.dbPath, config.migrationsFolder);
 	const git = createGitFactory(providers.credentials);
-	const github = async () => {
-		const token = await providers.credentials.getToken("github.com");
-		if (!token) {
-			throw new Error(
-				"No GitHub token available. Set GITHUB_TOKEN/GH_TOKEN or authenticate via git credential manager.",
-			);
-		}
-		return new Octokit({ auth: token });
-	};
+	const github =
+		options.github ??
+		(async () => {
+			const token = await providers.credentials.getToken("github.com");
+			if (!token) {
+				throw new Error(
+					"No GitHub token available. Set GITHUB_TOKEN/GH_TOKEN or authenticate via git credential manager.",
+				);
+			}
+			return new Octokit({ auth: token });
+		});
 
 	const pullRequestRuntime = new PullRequestRuntimeManager({
 		db,
@@ -66,14 +83,16 @@ export function createApp(options: CreateAppOptions): CreateAppResult {
 	});
 	pullRequestRuntime.start();
 	const filesystem = new WorkspaceFilesystemManager({ db });
-	const chatRuntime = new ChatRuntimeManager({
-		db,
-		runtimeResolver: providers.modelResolver,
-	});
+	const chatRuntime =
+		options.chatRuntime ??
+		new ChatRuntimeManager({
+			db,
+			runtimeResolver: providers.modelResolver,
+		});
 	// Provider auth (Anthropic / OpenAI OAuth + API keys) is per-machine, not
 	// per-workspace. ChatService is a long-lived singleton wrapping mastra's
 	// auth storage; the `host.auth.*` router proxies to it.
-	const chatService = new ChatService();
+	const chatService = options.chatService ?? new ChatService();
 
 	const runtime = {
 		auth: chatService,
@@ -146,5 +165,29 @@ export function createApp(options: CreateAppOptions): CreateAppResult {
 		}),
 	);
 
-	return { app, injectWebSocket, api };
+	const ownsDb = options.db === undefined;
+	const dispose = async (): Promise<void> => {
+		// Each step is best-effort and isolated: a throw in one cleanup must
+		// not skip the others, otherwise a flaky `.stop()` could leak the
+		// open SQLite handle for the rest of the process lifetime.
+		try {
+			pullRequestRuntime.stop();
+		} catch (err) {
+			console.warn("[host-service] pullRequestRuntime.stop failed:", err);
+		}
+		try {
+			eventBus.close();
+		} catch (err) {
+			console.warn("[host-service] eventBus.close failed:", err);
+		}
+		if (ownsDb) {
+			try {
+				(db as unknown as { $client?: { close: () => void } }).$client?.close();
+			} catch {
+				// best-effort close; tests should not fail on teardown
+			}
+		}
+	};
+
+	return { app, injectWebSocket, api, dispose };
 }

packages/host-service/src/trpc/router/git/git.ts

@@ -16,6 +16,7 @@ import type {
 	PullRequestReviewThread,
 	PullRequestState,
 } from "./types";
+import { gitConfigWrite } from "./utils/config-write";
 import {
 	buildBranch,
 	countUntrackedFileLines,
@@ -313,15 +314,17 @@ export const gitRouter = router({
 				});
 			}
 			if (input.baseBranch) {
-				await git.raw([
+				await gitConfigWrite(git, [
 					"config",
 					`branch.${currentBranch}.base`,
 					input.baseBranch,
 				]);
 			} else {
-				await git
-					.raw(["config", "--unset", `branch.${currentBranch}.base`])
-					.catch(() => {});
+				await gitConfigWrite(git, [
+					"config",
+					"--unset",
+					`branch.${currentBranch}.base`,
+				]).catch(() => {});
 			}
 			return { baseBranch: input.baseBranch };
 		}),

packages/host-service/src/trpc/router/git/utils/config-write.ts

@@ -0,0 +1,43 @@
+import type { SimpleGit } from "simple-git";
+
+/**
+ * Run a `git config` write with bounded retries on `.git/config.lock`
+ * contention.
+ *
+ * `git config` takes a per-config flock that's held for milliseconds.
+ * Two concurrent writes (e.g. a renderer double-click on the base-branch
+ * picker, or `setBaseBranch` racing with `workspaceCreation.create`'s
+ * own config write) cause one to fail with:
+ *
+ *   error: could not lock config file .git/config: File exists
+ *
+ * We catch that specific shape and retry with a short backoff so the
+ * second writer just waits its turn instead of bubbling a confusing 500
+ * to the renderer.
+ */
+export async function gitConfigWrite(
+	git: SimpleGit,
+	args: string[],
+	options: { retries?: number; baseDelayMs?: number } = {},
+): Promise<string> {
+	// `retries` is the number of *additional* attempts after the first try,
+	// so default 4 == 1 initial + 4 retries (5 total), with backoff
+	// 30/60/120/240ms between them. Clamped at 0 to keep the loop sane.
+	const retries = Math.max(0, options.retries ?? 4);
+	const baseDelayMs = options.baseDelayMs ?? 30;
+	let lastErr: unknown = new Error("gitConfigWrite: no attempt completed");
+	for (let attempt = 0; attempt <= retries; attempt++) {
+		try {
+			return await git.raw(args);
+		} catch (err) {
+			lastErr = err;
+			const message = err instanceof Error ? err.message : String(err);
+			if (!message.includes("could not lock config file")) throw err;
+			if (attempt === retries) break;
+			await new Promise((resolve) =>
+				setTimeout(resolve, baseDelayMs * 2 ** attempt),
+			);
+		}
+	}
+	throw lastErr;
+}

packages/host-service/src/trpc/router/workspace-creation/procedures/adopt.ts

@@ -4,6 +4,7 @@ import { and, eq, ne, or } from "drizzle-orm";
 import { workspaces } from "../../../../db/schema";
 import type { HostServiceContext } from "../../../../types";
 import { protectedProcedure } from "../../../index";
+import { gitConfigWrite } from "../../git/utils/config-write";
 import { ensureMainWorkspace } from "../../project/utils/ensure-main-workspace";
 import { adoptInputSchema } from "../schemas";
 import {
@@ -102,14 +103,16 @@ async function recordBaseBranch(
 	baseBranch: string | undefined,
 ): Promise<void> {
 	if (!baseBranch) return;
-	await git
-		.raw(["config", `branch.${branch}.base`, baseBranch])
-		.catch((err) => {
-			console.warn(
-				`[workspaceCreation.adopt] failed to record base branch ${baseBranch}:`,
-				err,
-			);
-		});
+	await gitConfigWrite(git as Parameters<typeof gitConfigWrite>[0], [
+		"config",
+		`branch.${branch}.base`,
+		baseBranch,
+	]).catch((err) => {
+		console.warn(
+			`[workspaceCreation.adopt] failed to record base branch ${baseBranch}:`,
+			err,
+		);
+	});
 }
 
 export const adopt = protectedProcedure