opencode-bridge.mjs

/**
 * ESM bridge module loaded by main.cjs via dynamic import().
 * Hosts OpenCodeConnection instances (one per project) and wires IPC handlers.
 *
 * This file MUST be .mjs so Electron's Node runtime treats it as ESM,
 * allowing us to import the ESM-only @opencode-ai/sdk.
 *
 * Uses v2 SDK which supports variant selection and named parameters.
 */

import { execSync, spawn } from "node:child_process";
import { existsSync } from "node:fs";
import { Agent } from "node:http";
import { Agent as HttpsAgent } from "node:https";
import { homedir } from "node:os";
import { join, normalize, sep } from "node:path";
import { createOpencodeClient } from "@opencode-ai/sdk/v2/client";

// ---------------------------------------------------------------------------
// Local server management
// ---------------------------------------------------------------------------

const LOCAL_SERVER_PORT = 4096;
const LOCAL_SERVER_URL = `http://127.0.0.1:${LOCAL_SERVER_PORT}`;
const STARTUP_POLL_INTERVAL = 500; // ms
const STARTUP_TIMEOUT = process.platform === "win32" ? 60_000 : 15_000; // ms

/** Resolve the opencode binary path (cross-platform). */
function resolveOpencodeBinary() {
	const isWindows = process.platform === "win32";
	const binaryName = isWindows ? "opencode.exe" : "opencode";
	// Prefer the canonical install location (~/.opencode/bin/)
	const preferred = join(homedir(), ".opencode", "bin", binaryName);
	if (existsSync(preferred)) return preferred;
	// Fall back to PATH
	if (isWindows) {
		// On Windows, `where opencode` may return extensionless bash shims
		// that spawn() cannot execute. Search for .exe first, then .cmd.
		for (const ext of [".exe", ".cmd"]) {
			try {
				const result = execSync(`where opencode${ext}`, {
					encoding: "utf-8",
				})
					.split(/\r?\n/)[0]
					.trim();
				if (result) return result;
			} catch {
				// not found with this extension
			}
		}
	} else {
		try {
			const fromPath = execSync("which opencode", { encoding: "utf-8" })
				.split(/\r?\n/)[0]
				.trim();
			if (fromPath) return fromPath;
		} catch {
			// not on PATH
		}
	}
	return null;
}

/** Fetch health info from the local server. Returns { healthy, version } or defaults. */
async function fetchLocalHealth() {
	try {
		const res = await fetch(`${LOCAL_SERVER_URL}/global/health`, {
			signal: AbortSignal.timeout(3000),
		});
		if (!res.ok) return { healthy: false, version: null };
		const data = await res.json();
		return { healthy: data.healthy === true, version: data.version ?? null };
	} catch {
		return { healthy: false, version: null };
	}
}

/** Return the version string from a local binary, or null. */
function getBinaryVersion(binaryPath) {
	try {
		return execSync(`"${binaryPath}" --version`, {
			encoding: "utf-8",
			timeout: 5000,
		}).trim();
	} catch {
		return null;
	}
}

/** Kill the opencode server process listening on LOCAL_SERVER_PORT. Returns true if killed. */
async function killServerProcess() {
	const isWindows = process.platform === "win32";
	let pid = null;

	if (isWindows) {
		try {
			const out = execSync(
				`netstat -ano | findstr :${LOCAL_SERVER_PORT} | findstr LISTENING`,
				{
					encoding: "utf-8",
					stdio: ["ignore", "pipe", "ignore"],
				},
			);
			const match = out.trim().split(/\s+/).pop();
			if (match) pid = Number.parseInt(match, 10);
		} catch {
			// no process found
		}
	} else {
		try {
			const out = execSync(`lsof -ti tcp:${LOCAL_SERVER_PORT}`, {
				encoding: "utf-8",
				stdio: ["ignore", "pipe", "ignore"],
			});
			const first = out.trim().split(/\s+/)[0];
			if (first) pid = Number.parseInt(first, 10);
		} catch {
			// no process found
		}
	}

	if (!pid || Number.isNaN(pid)) return false;

	try {
		process.kill(pid, isWindows ? "SIGKILL" : "SIGTERM");
	} catch {
		return false;
	}

	await new Promise((resolve) => setTimeout(resolve, 1000));

	if ((await fetchLocalHealth()).healthy) {
		try {
			process.kill(pid, "SIGKILL");
		} catch {
			// already dead
		}
		await new Promise((resolve) => setTimeout(resolve, 500));
		if ((await fetchLocalHealth()).healthy) return false;
	}

	return true;
}

/** Poll until healthy or timeout. */
function waitForHealthy(timeoutMs = STARTUP_TIMEOUT) {
	return new Promise((resolve, reject) => {
		const start = Date.now();
		const check = async () => {
			if ((await fetchLocalHealth()).healthy) return resolve(true);
			if (Date.now() - start > timeoutMs) {
				return reject(
					new Error(
						`Server did not become healthy within ${timeoutMs / 1000}s`,
					),
				);
			}
			setTimeout(check, STARTUP_POLL_INTERVAL);
		};
		void check();
	});
}

// ---------------------------------------------------------------------------
// URL safety helpers
// ---------------------------------------------------------------------------

// ---------------------------------------------------------------------------
// Inline connection manager (avoids needing to transpile TS in main process)
// ---------------------------------------------------------------------------

const BACKOFF_STEPS = [500, 1000, 2000, 5000]; // ms – fast first attempt
const HEALTH_INTERVAL = 30_000; // ms
const SSE_STALE_THRESHOLD = 45_000; // ms – restart SSE if no event for this long

// Keep-alive agents to prevent idle TCP connections from being dropped.
// Setting keepAlive + very long timeouts prevents OS/proxy idle-timeout kills.
const httpAgent = new Agent({ keepAlive: true, keepAliveMsecs: 15_000 });
const httpsAgent = new HttpsAgent({ keepAlive: true, keepAliveMsecs: 15_000 });

function stripMessagePayloadBloat(messages) {
	for (const message of messages) {
		const summary = message?.info?.summary;
		if (summary && typeof summary === "object" && "diffs" in summary) {
			delete summary.diffs;
		}

		if (!Array.isArray(message?.parts)) continue;
		for (const part of message.parts) {
			if (part?.type !== "tool") continue;
			const files = part?.state?.metadata?.files;
			if (!Array.isArray(files)) continue;
			for (const file of files) {
				if (
					file &&
					typeof file === "object" &&
					typeof file.diff === "string" &&
					file.diff.trim()
				) {
					delete file.before;
					delete file.after;
				}
			}
		}
	}
	return messages;
}

class OpenCodeConnection {
	constructor(emit) {
		this._emit = emit;
		this._lifecycle = 0;
		this._streamGeneration = 0;
		this._client = null;
		this._config = null;
		this._abortController = null;
		this._reconnectTimer = null;
		this._healthTimer = null;
		this._reconnectAttempt = 0;
		this._status = {
			state: "idle",
			serverUrl: null,
			serverVersion: null,
			error: null,
			lastEventAt: null,
		};
	}

	// - public ---------------------------------------------------------------

	async connect(config) {
		this.teardown();
		const lifecycle = ++this._lifecycle;
		this._config = config;
		this._client = this._makeClient(config);
		this._setStatus({
			state: "connecting",
			serverUrl: config.baseUrl,
			error: null,
		});

		try {
			await this._healthCheck();
			if (!this._isCurrent(lifecycle)) return;
			this._setStatus({ state: "connected" });
			void this._startSSE(lifecycle);
			this._startHealthTimer(lifecycle);
		} catch (err) {
			if (!this._isCurrent(lifecycle)) return;
			const msg = err instanceof Error ? err.message : String(err);
			this._setStatus({ state: "error", error: msg });
			throw err;
		}
	}

	disconnect() {
		this.teardown();
		this._setStatus({
			state: "idle",
			serverUrl: null,
			serverVersion: null,
			error: null,
			lastEventAt: null,
		});
	}

	getStatus() {
		return { ...this._status };
	}

	getDirectory() {
		return this._config?.directory ?? null;
	}

	// - sessions -------------------------------------------------------------

	async listSessions() {
		this._requireClient();
		// The server defaults to LIMIT 100. Request a high limit so all
		// sessions are returned regardless of how many the user has.
		// Pass the connection directory so sessions are scoped to this
		// project directory only – without this, the server returns ALL
		// sessions sharing the same git repo (project_id), which causes
		// cross-directory duplicates in the sidebar.
		const dir = this.getDirectory();
		const res = await this._client.session.list({
			roots: true,
			limit: 10000,
			...(dir ? { directory: dir } : {}),
		});
		return res.data ?? [];
	}

	async createSession(title) {
		this._requireClient();
		const normalizedTitle = typeof title === "string" ? title.trim() : "";
		const params = normalizedTitle ? { title: normalizedTitle } : undefined;
		const res = await this._client.session.create(params);
		return res.data;
	}

	async deleteSession(id) {
		this._requireClient();
		const res = await this._client.session.delete({ sessionID: id });
		return res.data;
	}

	async updateSession(id, title) {
		this._requireClient();
		const res = await this._client.session.update({ sessionID: id, title });
		return res.data;
	}

	async getSessionStatuses() {
		this._requireClient();
		const res = await this._client.session.status();
		return res.data ?? {};
	}

	// - revert / fork ---------------------------------------------------------

	async revertSession(sessionID, messageID, partID) {
		this._requireClient();
		const params = { sessionID, messageID };
		if (partID) params.partID = partID;
		const res = await this._client.session.revert(params);
		return res.data;
	}

	async unrevertSession(sessionID) {
		this._requireClient();
		const res = await this._client.session.unrevert({ sessionID });
		return res.data;
	}

	async forkSession(sessionID, messageID) {
		this._requireClient();
		const params = { sessionID };
		if (messageID) params.messageID = messageID;
		const res = await this._client.session.fork(params);
		return res.data;
	}

	// - providers / models ----------------------------------------------------

	async getProviders() {
		this._requireClient();
		const res = await this._client.config.providers();
		return res.data ?? { providers: [], default: {} };
	}

	async listAllProviders() {
		this._requireClient();
		const res = await this._client.provider.list();
		return res.data ?? { all: [], default: {}, connected: [] };
	}

	async getProviderAuthMethods() {
		this._requireClient();
		const res = await this._client.provider.auth();
		return res.data ?? {};
	}

	async setProviderAuth(providerID, auth) {
		this._requireClient();
		const res = await this._client.auth.set({ providerID, auth });
		return res.data;
	}

	async removeProviderAuth(providerID) {
		this._requireClient();
		const res = await this._client.auth.remove({ providerID });
		return res.data;
	}

	async oauthAuthorize(providerID, method) {
		this._requireClient();
		const params = { providerID };
		if (method !== undefined) params.method = method;
		const res = await this._client.provider.oauth.authorize(params);
		return res.data;
	}

	async oauthCallback(providerID, method, code) {
		this._requireClient();
		const params = { providerID };
		if (method !== undefined) params.method = method;
		if (code !== undefined) params.code = code;
		const res = await this._client.provider.oauth.callback(params);
		return res.data;
	}

	async disposeInstance() {
		this._requireClient();
		const res = await this._client.instance.dispose();
		return res.data;
	}

	// - agents ---------------------------------------------------------------

	async getAgents() {
		this._requireClient();
		const res = await this._client.app.agents();
		return res.data ?? [];
	}

	// - messages -------------------------------------------------------------

	async getMessages(sessionId, options = {}) {
		this._requireClient();
		const params = { sessionID: sessionId };
		if (typeof options.limit === "number" && Number.isFinite(options.limit)) {
			params.limit = options.limit;
		}
		if (typeof options.before === "string" && options.before.trim()) {
			params.before = options.before;
		}
		const res = await this._client.session.messages(params);
		const messages = stripMessagePayloadBloat(res.data ?? []);
		// Extract the opaque pagination cursor from the response header.
		const nextCursor = res.response?.headers?.get("X-Next-Cursor") ?? null;
		return { messages, nextCursor };
	}

	async promptAsync(sessionId, text, images, model, agent, variant) {
		this._requireClient();
		const parts = [{ type: "text", text }];
		if (images) {
			for (const url of images) {
				// Attempt to detect MIME from data-URI header or file extension
				let mime = "image/png";
				const dataMatch = url.match(/^data:(image\/[^;,]+)/);
				if (dataMatch) {
					mime = dataMatch[1];
				} else {
					const ext = url.split(".").pop()?.toLowerCase();
					if (ext === "jpg" || ext === "jpeg") mime = "image/jpeg";
					else if (ext === "gif") mime = "image/gif";
					else if (ext === "webp") mime = "image/webp";
					else if (ext === "svg") mime = "image/svg+xml";
				}
				parts.push({ type: "file", mime, url });
			}
		}
		const params = { sessionID: sessionId, parts };
		if (model) {
			params.model = model;
		}
		if (agent) {
			params.agent = agent;
		}
		if (variant) {
			params.variant = variant;
		}
		await this._client.session.promptAsync(params);
	}

	async abortSession(sessionId) {
		this._requireClient();
		await this._client.session.abort({ sessionID: sessionId });
	}

	// - permissions ----------------------------------------------------------

	async respondPermission(sessionId, permissionId, response) {
		this._requireClient();
		await this._client.permission.respond({
			sessionID: sessionId,
			permissionID: permissionId,
			response,
		});
	}

	// - commands -------------------------------------------------------------

	async listCommands() {
		this._requireClient();
		const res = await this._client.command.list();
		return res.data ?? [];
	}

	async sendCommand(sessionId, command, args, model, agent, variant) {
		this._requireClient();
		const params = { sessionID: sessionId, command, arguments: args };
		if (model) params.model = `${model.providerID}/${model.modelID}`;
		if (agent) params.agent = agent;
		if (variant) params.variant = variant;
		await this._client.session.command(params);
	}

	// - questions ------------------------------------------------------------

	async replyQuestion(requestID, answers) {
		this._requireClient();
		await this._client.question.reply({ requestID, answers });
	}

	async rejectQuestion(requestID) {
		this._requireClient();
		await this._client.question.reject({ requestID });
	}

	// - MCP ------------------------------------------------------------------

	async getMcpStatus() {
		this._requireClient();
		const res = await this._client.mcp.status();
		return res.data ?? {};
	}

	async addMcp(name, config) {
		this._requireClient();
		const res = await this._client.mcp.add({ name, config });
		return res.data ?? {};
	}

	async connectMcp(name) {
		this._requireClient();
		await this._client.mcp.connect({ name });
	}

	async disconnectMcp(name) {
		this._requireClient();
		await this._client.mcp.disconnect({ name });
	}

	// - Config ---------------------------------------------------------------

	async getConfig() {
		this._requireClient();
		const res = await this._client.config.get();
		return res.data ?? {};
	}

	async updateConfig(config) {
		this._requireClient();
		const res = await this._client.config.update({ config });
		return res.data ?? {};
	}

	// - Skills ---------------------------------------------------------------

	async getSkills() {
		this._requireClient();
		const res = await this._client.app.skills();
		return res.data ?? [];
	}

	// - File search ----------------------------------------------------------

	async findFiles(query) {
		this._requireClient();
		const res = await this._client.find.files({ query });
		return res.data ?? [];
	}

	// - internal -------------------------------------------------------------

	_requireClient() {
		if (!this._client) throw new Error("Not connected to any opencode server");
	}

	_makeAuthHeaders(config) {
		const headers = {};
		if (config.password) {
			const user = config.username ?? "opencode";
			headers.Authorization = `Basic ${Buffer.from(`${user}:${config.password}`).toString("base64")}`;
		}
		return headers;
	}

	_makeClient(config) {
		const headers = this._makeAuthHeaders(config);
		const directory =
			typeof config.directory === "string" ? config.directory.trim() : "";

		// Custom fetch that uses keep-alive agents to prevent idle connection drops.
		const customFetch = (input, init) => {
			const url =
				typeof input === "string"
					? input
					: input instanceof URL
						? input.href
						: input.url;
			const agent = url?.startsWith("https") ? httpsAgent : httpAgent;
			return globalThis.fetch(input, { ...init, agent });
		};

		return createOpencodeClient({
			baseUrl: config.baseUrl.replace(/\/+$/, ""),
			headers,
			fetch: customFetch,
			...(directory ? { directory } : {}),
		});
	}

	async _healthCheck() {
		this._requireClient();
		try {
			const res = await this._client.global.health();
			const data = res.data;
			if (data?.version) this._setStatus({ serverVersion: data.version });
			if (!data?.healthy) throw new Error("Server reports unhealthy");
		} catch (err) {
			// If the v2 global.health() fails with a method-not-found-style error,
			// fall back to raw fetch (older servers may not support this endpoint via SDK)
			if (err?.message?.includes("unhealthy")) throw err;
			const url = `${this._config.baseUrl.replace(/\/+$/, "")}/global/health`;
			const headers = this._makeAuthHeaders(this._config);
			const rawRes = await fetch(url, { headers });
			if (!rawRes.ok)
				throw new Error(
					`Health check failed: ${rawRes.status} ${rawRes.statusText}`,
				);
			const data = await rawRes.json();
			if (data.version) this._setStatus({ serverVersion: data.version });
			if (!data.healthy) throw new Error("Server reports unhealthy");
		}
	}

	_isCurrent(lifecycle) {
		return lifecycle === this._lifecycle;
	}

	async _startSSE(lifecycle) {
		if (!this._isCurrent(lifecycle)) return;
		this._requireClient();
		const streamGeneration = ++this._streamGeneration;
		const abortController = new AbortController();
		this._abortController = abortController;

		try {
			const events = await this._client.event.subscribe({
				signal: abortController.signal,
				// Disable SDK-level retry - we handle reconnection at the app level
				// with our own backoff. Without this, the SDK silently retries with
				// exponential backoff (3s/6s/12s/24s/30s) and the app has no
				// visibility into the disconnect.
				sseMaxRetryAttempts: 1,
				onSseError: (err) =>
					console.warn("[OpenCodeConnection] SDK SSE error:", err),
			});

			const stream = events.stream ?? events;
			for await (const event of stream) {
				if (
					abortController.signal.aborted ||
					this._streamGeneration !== streamGeneration ||
					!this._isCurrent(lifecycle)
				) {
					break;
				}

				const payload = event.properties ? event : event.payload;
				if (payload) {
					this._emit({ type: "opencode:event", payload });
					this._setStatus({ lastEventAt: Date.now() });
				}
				this._reconnectAttempt = 0;
			}

			// Stream ended cleanly (server closed the connection).
			// Reconnect unless we intentionally aborted.
			if (
				!abortController.signal.aborted &&
				this._streamGeneration === streamGeneration
			) {
				console.warn(
					"[OpenCodeConnection] SSE stream ended cleanly, reconnecting...",
				);
				this._scheduleReconnect(lifecycle);
			}
		} catch (err) {
			if (
				abortController.signal.aborted ||
				this._streamGeneration !== streamGeneration ||
				!this._isCurrent(lifecycle)
			) {
				return;
			}
			console.error("[OpenCodeConnection] SSE error:", err);
			this._scheduleReconnect(lifecycle);
		}
	}

	_scheduleReconnect(lifecycle) {
		if (!this._config || !this._isCurrent(lifecycle)) return;
		if (this._reconnectTimer) {
			clearTimeout(this._reconnectTimer);
			this._reconnectTimer = null;
		}
		const delay =
			BACKOFF_STEPS[Math.min(this._reconnectAttempt, BACKOFF_STEPS.length - 1)];
		this._reconnectAttempt++;
		this._setStatus({
			state: "reconnecting",
			error: `Reconnecting in ${delay / 1000}s...`,
		});

		this._reconnectTimer = setTimeout(async () => {
			if (!this._isCurrent(lifecycle)) return;
			try {
				await this._healthCheck();
				if (!this._isCurrent(lifecycle)) return;
				this._setStatus({ state: "connected", error: null });
				void this._startSSE(lifecycle);
			} catch {
				this._scheduleReconnect(lifecycle);
			}
		}, delay);
	}

	_startHealthTimer(lifecycle) {
		if (!this._isCurrent(lifecycle)) return;
		this._stopHealthTimer();
		this._healthTimer = setInterval(async () => {
			if (!this._isCurrent(lifecycle)) {
				this._stopHealthTimer();
				return;
			}
			try {
				await this._healthCheck();
				if (!this._isCurrent(lifecycle)) return;

				// If the server is healthy but SSE has gone stale (no events
				// for longer than the stale threshold), proactively restart.
				const lastEvent = this._status.lastEventAt;
				if (
					lastEvent &&
					Date.now() - lastEvent > SSE_STALE_THRESHOLD &&
					this._status.state === "connected"
				) {
					console.warn(
						"[OpenCodeConnection] SSE stream appears stale, restarting...",
					);
					// Abort the old stream and wait briefly for it to unwind
					// before starting a fresh one to avoid overlapping streams.
					this._abortController?.abort();
					await new Promise((r) => setTimeout(r, 100));
					void this._startSSE(lifecycle);
				}
			} catch {
				// Server unreachable - actively trigger reconnect instead of
				// waiting for the SSE stream to eventually break on its own.
				if (this._status.state === "connected") {
					console.warn(
						"[OpenCodeConnection] Health check failed while connected, reconnecting...",
					);
					this._abortController?.abort();
					this._stopHealthTimer();
					this._scheduleReconnect(lifecycle);
				}
			}
		}, HEALTH_INTERVAL);
	}

	_stopHealthTimer() {
		if (this._healthTimer) {
			clearInterval(this._healthTimer);
			this._healthTimer = null;
		}
	}

	_setStatus(patch) {
		this._status = { ...this._status, ...patch };
		this._emit({ type: "connection:status", payload: { ...this._status } });
	}

	teardown() {
		this._lifecycle++;
		this._abortController?.abort();
		this._abortController = null;
		if (this._reconnectTimer) {
			clearTimeout(this._reconnectTimer);
			this._reconnectTimer = null;
		}
		this._stopHealthTimer();
		this._reconnectAttempt = 0;
		this._client = null;
		this._config = null;
	}
}

// ---------------------------------------------------------------------------
// Setup: called from main.cjs with (ipcMain, mainWindow)
// ---------------------------------------------------------------------------

export function setupOpenCodeBridge(ipcMain, _getWindows) {
	/** @type {Map<number, {
	 *   connections: Map<string, OpenCodeConnection>,
	 *   sessionDirectoryMap: Map<string, string>,
	 *   questionDirectoryMap: Map<string, string>,
	 *   serverConfig: { baseUrl: string, username?: string, password?: string } | null,
	 * }>} */
	const windowStates = new Map();

	function getWindowState(sender) {
		const key = sender.id;
		let state = windowStates.get(key);
		if (state) return state;
		state = {
			connections: new Map(),
			sessionDirectoryMap: new Map(),
			questionDirectoryMap: new Map(),
			serverConfig: null,
		};
		windowStates.set(key, state);
		sender.once("destroyed", () => {
			const current = windowStates.get(key);
			if (!current) return;
			for (const conn of current.connections.values()) {
				conn.teardown();
			}
			windowStates.delete(key);
		});
		return state;
	}

	function normalizeServerConfig(config) {
		return {
			baseUrl: config.baseUrl.replace(/\/+$/, ""),
			username: config.username?.trim() || undefined,
			password: config.password?.trim() || undefined,
		};
	}

	function sendEvent(sender, event) {
		if (!sender.isDestroyed()) {
			sender.send("opencode:bridge-event", event);
		}
	}

	function createConnection(windowState, sender, directory) {
		const conn = new OpenCodeConnection((event) => {
			if (windowState.connections.get(directory) !== conn) return;
			if (event?.type === "opencode:event") {
				const payload = event.payload;
				if (payload?.type === "question.asked") {
					const questionId = payload?.properties?.id;
					if (questionId) {
						windowState.questionDirectoryMap.set(questionId, directory);
					}
				}
				if (
					payload?.type === "question.replied" ||
					payload?.type === "question.rejected"
				) {
					const requestID = payload?.properties?.requestID;
					if (requestID) windowState.questionDirectoryMap.delete(requestID);
				}
				// Register session IDs (including child/subagent sessions) so
				// getConnectionForSession can resolve them for message fetches.
				if (
					payload?.type === "session.created" ||
					payload?.type === "session.updated"
				) {
					const info = payload?.properties?.info;
					if (info?.id) {
						windowState.sessionDirectoryMap.set(info.id, directory);
					}
				}
			}
			// Tag every event with the directory it came from
			sendEvent(sender, { ...event, directory });
		});
		windowState.connections.set(directory, conn);
		return conn;
	}

	/** Find which connection owns a session by looking up the cache. */
	function getConnectionForSession(windowState, sessionId) {
		const dir = windowState.sessionDirectoryMap.get(sessionId);
		if (dir) {
			const conn = windowState.connections.get(dir);
			if (conn) return conn;
		}
		// Fallback: try any connected connection. Child/subagent sessions are
		// not returned by listSessions, so they may not be in sessionDirectoryMap
		// after an app restart. Session IDs are globally unique, so the correct
		// server will handle it and others will return an error.
		for (const conn of windowState.connections.values()) {
			if (conn.getStatus().state === "connected") return conn;
		}
		return null;
	}

	/** Get any connected connection (for global operations like providers/agents). */
	function getAnyConnection(windowState) {
		for (const conn of windowState.connections.values()) {
			if (conn.getStatus().state === "connected") return conn;
		}
		return null;
	}

	/** Resolve a connection for a specific project directory. */
	function getConnectionForDirectory(windowState, directory) {
		if (typeof directory !== "string" || !directory.trim()) {
			return getAnyConnection(windowState);
		}

		const requested = normalize(directory.trim());

		for (const [dir, conn] of windowState.connections) {
			if (normalize(dir) === requested) return conn;
		}

		for (const [dir, conn] of windowState.connections) {
			const normalizedDir = normalize(dir);
			if (
				requested.startsWith(normalizedDir) &&
				(requested.length === normalizedDir.length ||
					requested[normalizedDir.length] === sep)
			) {
				return conn;
			}
		}

		return getAnyConnection(windowState);
	}

	// --- IPC handler factories (DRY helpers to eliminate boilerplate) ---

	/**
	 * Register a global-operation IPC handler that uses getAnyConnection().
	 * @param {string} channel - IPC channel name
	 * @param {(conn: OpenCodeConnection, ...args: any[]) => Promise<any>} fn
	 */
	function handleGlobalOp(channel, fn) {
		ipcMain.handle(channel, async (event, ...args) => {
			try {
				const windowState = getWindowState(event.sender);
				const conn = getAnyConnection(windowState);
				if (!conn) return { success: false, error: "No connection available" };
				const data = await fn(conn, ...args);
				return data === undefined ? { success: true } : { success: true, data };
			} catch (err) {
				return { success: false, error: err.message };
			}
		});
	}

	/**
	 * Register a directory-aware IPC handler whose first arg is a directory.
	 * @param {string} channel - IPC channel name
	 * @param {(conn: OpenCodeConnection, ...args: any[]) => Promise<any>} fn
	 */
	function handleDirectoryOp(channel, fn) {
		ipcMain.handle(channel, async (event, directory, ...args) => {
			try {
				const windowState = getWindowState(event.sender);
				const conn = getConnectionForDirectory(windowState, directory);
				if (!conn) return { success: false, error: "No connection available" };
				const data = await fn(conn, ...args);
				return data === undefined ? { success: true } : { success: true, data };
			} catch (err) {
				return { success: false, error: err.message };
			}
		});
	}

	/**
	 * Register a session-routed IPC handler that uses getConnectionForSession().
	 * The first arg after _event is always sessionId.
	 * @param {string} channel - IPC channel name
	 * @param {(conn: OpenCodeConnection, sessionId: string, ...args: any[]) => Promise<any>} fn
	 */
	function handleSessionOp(channel, fn) {
		ipcMain.handle(channel, async (event, sessionId, ...args) => {
			try {
				const windowState = getWindowState(event.sender);
				const conn = getConnectionForSession(windowState, sessionId);
				if (!conn)
					return { success: false, error: "Session connection not found" };
				const data = await fn(conn, sessionId, ...args);
				return data === undefined ? { success: true } : { success: true, data };
			} catch (err) {
				return { success: false, error: err.message };
			}
		});
	}

	/**
	 * Register an IPC handler for question operations that prefers
	 * requestID -> directory routing, then falls back to trying all connections.
	 * @param {string} channel - IPC channel name
	 * @param {(conn: OpenCodeConnection, requestID: string, ...args: any[]) => Promise<any>} fn
	 */
	function handleQuestionOp(channel, fn) {
		ipcMain.handle(channel, async (event, requestID, ...args) => {
			try {
				const windowState = getWindowState(event.sender);
				if (typeof requestID !== "string" || !requestID.trim()) {
					return { success: false, error: "Question requestID is required" };
				}

				const mappedDirectory = windowState.questionDirectoryMap.get(requestID);
				if (mappedDirectory) {
					const mappedConn = windowState.connections.get(mappedDirectory);
					if (mappedConn) {
						const data = await fn(mappedConn, requestID, ...args);
						windowState.questionDirectoryMap.delete(requestID);
						return data === undefined
							? { success: true }
							: { success: true, data };
					}
					windowState.questionDirectoryMap.delete(requestID);
				}

				let lastErr;
				for (const conn of windowState.connections.values()) {
					try {
						const data = await fn(conn, requestID, ...args);
						windowState.questionDirectoryMap.delete(requestID);
						return data === undefined
							? { success: true }
							: { success: true, data };
					} catch (err) {
						lastErr = err;
					}
				}

				return {
					success: false,
					error: lastErr?.message ?? "No connection available",
				};
			} catch (err) {
				return { success: false, error: err.message };
			}
		});
	}

	/**
	 * Run a git command and return the result in the standard IPC envelope.
	 * @param {string} directory - The cwd for git
	 * @param {string} command - The git command to run (without "git" prefix)
	 * @param {Array} [stdio] - stdio config (default: ["ignore", "pipe", "ignore"])
	 * @returns {string} Raw stdout
	 */
	function runGit(directory, command, stdio = ["ignore", "pipe", "ignore"]) {
		return execSync(`git ${command}`, {
			cwd: directory,
			encoding: "utf-8",
			stdio,
		});
	}

	// --- Project management ---

	ipcMain.handle("opencode:project:add", async (event, config) => {
		const windowState = getWindowState(event.sender);
		if (!config || typeof config !== "object") {
			return { success: false, error: "Invalid config" };
		}
		if (typeof config.baseUrl !== "string" || !config.baseUrl.trim()) {
			return { success: false, error: "Server URL is required" };
		}
		const directory = (config.directory ?? "").trim();
		if (!directory) {
			return { success: false, error: "Directory is required" };
		}
		const normalizedConfig = normalizeServerConfig(config);
		try {
			// Tear down existing connection for this directory if any
			const existing = windowState.connections.get(directory);
			if (existing) {
				existing.teardown();
				windowState.connections.delete(directory);
			}
			const conn = createConnection(windowState, event.sender, directory);
			await conn.connect(config);
			windowState.serverConfig = normalizedConfig;
			return { success: true, status: conn.getStatus() };
		} catch (err) {
			if (windowState.connections.get(directory)) {
				windowState.connections.delete(directory);
			}
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("opencode:project:remove", (event, directory) => {
		const windowState = getWindowState(event.sender);
		if (typeof directory !== "string" || !directory.trim()) {
			return { success: false, error: "Directory is required" };
		}
		const conn = windowState.connections.get(directory);
		if (conn) {
			conn.teardown();
			windowState.connections.delete(directory);
			// Clean up session mappings for this directory
			for (const [sid, dir] of windowState.sessionDirectoryMap) {
				if (dir === directory) windowState.sessionDirectoryMap.delete(sid);
			}
			for (const [requestID, dir] of windowState.questionDirectoryMap) {
				if (dir === directory)
					windowState.questionDirectoryMap.delete(requestID);
			}
		}
		if (windowState.connections.size === 0) {
			windowState.serverConfig = null;
		}
		return { success: true };
	});

	ipcMain.handle("opencode:disconnect", (event) => {
		const windowState = getWindowState(event.sender);
		for (const conn of windowState.connections.values()) {
			conn.teardown();
		}
		windowState.connections.clear();
		windowState.sessionDirectoryMap.clear();
		windowState.questionDirectoryMap.clear();
		windowState.serverConfig = null;
		return { success: true };
	});

	// --- Session operations ---

	/** Tag sessions with their directory and cache the mappings. */
	async function listAndCacheSessions(conn, dir) {
		const sessions = (await conn.listSessions()).map((s) => ({
			...s,
			_projectDir: dir,
		}));
		return sessions;
	}

	function cacheSessions(windowState, sessions, dir) {
		for (const s of sessions) {
			windowState.sessionDirectoryMap.set(s.id, dir);
		}
	}

	ipcMain.handle("opencode:session:list", async (event, directory) => {
		try {
			const windowState = getWindowState(event.sender);
			if (directory) {
				const conn = windowState.connections.get(directory);
				if (!conn) return { success: false, error: "Project not connected" };
				const sessions = await listAndCacheSessions(conn, directory);
				cacheSessions(windowState, sessions, directory);
				return {
					success: true,
					data: sessions,
				};
			}
			// List sessions from ALL projects
			const allSessions = [];
			for (const [dir, conn] of windowState.connections) {
				try {
					const sessions = await listAndCacheSessions(conn, dir);
					cacheSessions(windowState, sessions, dir);
					allSessions.push(...sessions);
				} catch {
					// Skip failed connections
				}
			}
			return { success: true, data: allSessions };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	ipcMain.handle("opencode:session:create", async (event, title, directory) => {
		try {
			const windowState = getWindowState(event.sender);
			const conn = directory
				? windowState.connections.get(directory)
				: getAnyConnection(windowState);
			if (!conn) return { success: false, error: "No connection available" };
			const session = await conn.createSession(title);
			if (session) {
				const dir = directory || conn.getDirectory();
				if (dir) windowState.sessionDirectoryMap.set(session.id, dir);
			}
			return { success: true, data: session };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	ipcMain.handle("opencode:session:delete", async (event, id) => {
		try {
			const windowState = getWindowState(event.sender);
			const conn = getConnectionForSession(windowState, id);
			if (!conn) {
				return { success: false, error: "Session connection not found" };
			}
			const result = await conn.deleteSession(id);
			windowState.sessionDirectoryMap.delete(id);
			return { success: true, data: result };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	handleSessionOp("opencode:session:update", (conn, id, title) =>
		conn.updateSession(id, title),
	);

	ipcMain.handle("opencode:session:statuses", async (event, directory) => {
		try {
			const windowState = getWindowState(event.sender);
			const conn = directory
				? windowState.connections.get(directory)
				: getAnyConnection(windowState);
			if (!conn) return { success: false, error: "No connection available" };
			const statuses = await conn.getSessionStatuses();
			return { success: true, data: statuses };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	handleSessionOp("opencode:session:revert", (conn, id, messageID, partID) =>
		conn.revertSession(id, messageID, partID),
	);
	handleSessionOp("opencode:session:unrevert", (conn, id) =>
		conn.unrevertSession(id),
	);

	ipcMain.handle("opencode:session:fork", async (event, id, messageID) => {
		try {
			const windowState = getWindowState(event.sender);
			const conn = getConnectionForSession(windowState, id);
			if (!conn)
				return { success: false, error: "Session connection not found" };
			const result = await conn.forkSession(id, messageID);
			// Register the new forked session in the directory map so future
			// operations can find the correct connection.
			if (result?.id) {
				const dir = [...windowState.connections.entries()].find(
					([, c]) => c === conn,
				)?.[0];
				if (dir) windowState.sessionDirectoryMap.set(result.id, dir);
			}
			return { success: true, data: result };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	// --- Providers / models (directory-aware) ---

	handleDirectoryOp("opencode:providers", (conn) => conn.getProviders());

	// --- Provider management (directory-aware) ---

	handleDirectoryOp("opencode:provider:list", (conn) =>
		conn.listAllProviders(),
	);
	handleDirectoryOp("opencode:provider:auth-methods", (conn) =>
		conn.getProviderAuthMethods(),
	);
	handleDirectoryOp("opencode:provider:connect", (conn, providerID, auth) =>
		conn.setProviderAuth(providerID, auth),
	);
	handleDirectoryOp("opencode:provider:disconnect", (conn, providerID) =>
		conn.removeProviderAuth(providerID),
	);
	handleDirectoryOp(
		"opencode:provider:oauth:authorize",
		(conn, providerID, method) => conn.oauthAuthorize(providerID, method),
	);
	handleDirectoryOp(
		"opencode:provider:oauth:callback",
		(conn, providerID, method, code) =>
			conn.oauthCallback(providerID, method, code),
	);
	handleDirectoryOp("opencode:instance:dispose", (conn) =>
		conn.disposeInstance(),
	);

	// --- Agents (directory-aware) ---

	handleDirectoryOp("opencode:agents", (conn) => conn.getAgents());

	// --- Message operations (routed to session's connection) ---

	handleSessionOp("opencode:messages", (conn, sessionId, options) =>
		conn.getMessages(sessionId, options),
	);
	handleSessionOp(
		"opencode:prompt",
		(conn, sessionId, text, images, model, agent, variant) =>
			conn.promptAsync(sessionId, text, images, model, agent, variant),
	);
	handleSessionOp("opencode:abort", (conn, sessionId) =>
		conn.abortSession(sessionId),
	);

	// --- Permission response (routed to session's connection) ---

	handleSessionOp(
		"opencode:permission",
		(conn, sessionId, permissionId, response) =>
			conn.respondPermission(sessionId, permissionId, response),
	);

	// --- Question response (try all connections) ---

	handleQuestionOp("opencode:question:reply", (conn, requestID, answers) =>
		conn.replyQuestion(requestID, answers),
	);

	// --- Commands (global) ---

	handleDirectoryOp("opencode:commands", (conn) => conn.listCommands());
	handleSessionOp(
		"opencode:command:send",
		(conn, sessionId, command, args, model, agent, variant) =>
			conn.sendCommand(sessionId, command, args, model, agent, variant),
	);
	handleQuestionOp("opencode:question:reject", (conn, requestID) =>
		conn.rejectQuestion(requestID),
	);

	// --- MCP operations (global) ---

	handleGlobalOp("opencode:mcp:status", (conn) => conn.getMcpStatus());
	handleGlobalOp("opencode:mcp:add", (conn, name, config) =>
		conn.addMcp(name, config),
	);
	handleGlobalOp("opencode:mcp:connect", (conn, name) => conn.connectMcp(name));
	handleGlobalOp("opencode:mcp:disconnect", (conn, name) =>
		conn.disconnectMcp(name),
	);

	// --- Config operations (directory-aware) ---

	handleDirectoryOp("opencode:config:get", (conn) => conn.getConfig());

	ipcMain.handle("opencode:config:update", async (event, directory, config) => {
		try {
			if (!config || typeof config !== "object") {
				return { success: false, error: "Invalid config" };
			}
			const windowState = getWindowState(event.sender);
			const conn = getConnectionForDirectory(windowState, directory);
			if (!conn) return { success: false, error: "No connection available" };
			return { success: true, data: await conn.updateConfig(config) };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	// --- Skills operations (directory-aware) ---

	handleDirectoryOp("opencode:skills", (conn) => conn.getSkills());

	// --- File search (directory-specific) ---

	ipcMain.handle("opencode:find:files", async (event, directory, query) => {
		try {
			const windowState = getWindowState(event.sender);
			let conn = null;
			if (directory) {
				const norm = normalize(directory);
				conn = windowState.connections.get(norm);
				if (!conn) {
					// Fallback: search for a connection whose directory is a prefix of the requested directory
					// (handles subfolders and worktrees that might not have their own connection)
					for (const [dir, c] of windowState.connections) {
						if (
							norm.startsWith(dir) &&
							(norm.length === dir.length || norm[dir.length] === sep)
						) {
							conn = c;
							break;
						}
					}
				}
			}

			if (!conn) conn = getAnyConnection(windowState);
			if (!conn) return { success: false, error: "No connection available" };

			const data = await conn.findFiles(query);
			return { success: true, data };
		} catch (err) {
			return { success: false, error: err.message };
		}
	});

	// --- Local server management ---

	ipcMain.handle("opencode:server:start", async () => {
		try {
			const binary = resolveOpencodeBinary();

			// If already running, check version matches the local binary
			const health = await fetchLocalHealth();
			if (health.healthy) {
				const serverVer = health.version;
				const binaryVer = binary ? getBinaryVersion(binary) : null;
				if (!serverVer || !binaryVer || serverVer === binaryVer) {
					return { success: true, data: { alreadyRunning: true } };
				}
				// Version mismatch - kill the old server and respawn below
				await killServerProcess();
			}
			console.log(
				`[opencode-bridge] Resolved binary: ${binary ?? "(not found)"} (platform: ${process.platform})`,
			);
			if (!binary) {
				return {
					success: false,
					error:
						"Could not find the opencode binary. Make sure it is installed at ~/.opencode/bin/opencode or available on your PATH.",
				};
			}

			// Spawn detached so the server survives app close.
			// Use piped stdio so we can capture logs on startup failure.
			const serverArgs = ["serve", "--port", String(LOCAL_SERVER_PORT)];
			console.log(
				`[opencode-bridge] Spawning: ${binary} ${serverArgs.join(" ")} (platform: ${process.platform})`,
			);

			const MAX_LOG_BYTES = 8192;
			let logBuffer = "";
			/** @type {number | null} */
			let earlyExitCode = null;

			const appendLog = (chunk) => {
				if (logBuffer.length < MAX_LOG_BYTES) {
					logBuffer += chunk
						.toString()
						.slice(0, MAX_LOG_BYTES - logBuffer.length);
				}
			};

			// .cmd files on Windows require shell:true for spawn() to execute them
			const needsShell =
				process.platform === "win32" && binary.toLowerCase().endsWith(".cmd");
			const child = spawn(binary, serverArgs, {
				detached: process.platform !== "win32",
				stdio: ["ignore", "pipe", "pipe"],
				windowsHide: true,
				shell: needsShell,
				env: { ...process.env },
			});

			if (child.stdout) child.stdout.on("data", appendLog);
			if (child.stderr) child.stderr.on("data", appendLog);

			child.on("close", (code) => {
				earlyExitCode = code;
			});

			child.unref();

			// If spawn itself errors (e.g. ENOENT)
			let spawnError = null;
			child.on("error", (err) => {
				spawnError = err;
				console.error(
					"[opencode-bridge] Failed to spawn opencode server:",
					err,
				);
			});

			// Wait for the server to become healthy
			console.log(
				`[opencode-bridge] Waiting for server to become healthy (timeout: ${STARTUP_TIMEOUT / 1000}s)...`,
			);
			try {
				await waitForHealthy();
			} catch (healthErr) {
				// Detach the stdio streams before returning the error
				if (child.stdout) {
					child.stdout.removeAllListeners("data");
					child.stdout.destroy();
				}
				if (child.stderr) {
					child.stderr.removeAllListeners("data");
					child.stderr.destroy();
				}

				let errorMsg = healthErr.message ?? String(healthErr);
				if (spawnError) {
					errorMsg = `Spawn error: ${spawnError.message}`;
				} else if (earlyExitCode !== null && earlyExitCode !== 0) {
					// Non-zero exit means the server actually crashed.
					// Exit code 0 is normal when the binary daemonizes (spawns a
					// background server and the launcher exits cleanly), so we
					// keep the health-check timeout message instead.
					errorMsg = `Server process exited with code ${Number(earlyExitCode)}`;
				}
				return {
					success: false,
					error: errorMsg,
					logs: logBuffer || null,
				};
			}

			// Server is healthy - detach the stdio streams so the process
			// can survive app close without keeping pipes open.
			if (child.stdout) {
				child.stdout.removeAllListeners("data");
				child.stdout.destroy();
			}
			if (child.stderr) {
				child.stderr.removeAllListeners("data");
				child.stderr.destroy();
			}

			console.log("[opencode-bridge] Server is healthy.");
			return { success: true, data: { alreadyRunning: false } };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("opencode:server:stop", async () => {
		try {
			if (!(await fetchLocalHealth()).healthy) {
				return { success: true, data: { alreadyStopped: true } };
			}
			const killed = await killServerProcess();
			if (!killed) {
				return {
					success: false,
					error: "Server process could not be stopped",
				};
			}
			return { success: true, data: {} };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("opencode:server:status", async () => {
		try {
			const running = (await fetchLocalHealth()).healthy;
			return { success: true, data: { running } };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	// --- Git helpers ---

	ipcMain.handle("git:is-repo", async (_event, directory) => {
		try {
			runGit(directory, "rev-parse --git-dir");
			return { success: true, data: true };
		} catch {
			return { success: true, data: false };
		}
	});

	ipcMain.handle("git:branch:list", async (_event, directory) => {
		try {
			const raw = runGit(directory, 'branch -a --format="%(refname:short)"');
			const branches = raw
				.split(/\r?\n/)
				.map((b) => b.trim())
				.filter(Boolean);
			return { success: true, data: branches };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("git:current-branch", async (_event, directory) => {
		try {
			const branch = runGit(directory, "rev-parse --abbrev-ref HEAD").trim();
			return { success: true, data: branch };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("git:worktree:list", async (_event, directory) => {
		try {
			const raw = runGit(directory, "worktree list --porcelain");
			const worktrees = [];
			let current = {};
			for (const line of raw.split(/\r?\n/)) {
				if (line.startsWith("worktree ")) {
					if (current.path) worktrees.push(current);
					current = { path: line.slice("worktree ".length) };
				} else if (line.startsWith("HEAD ")) {
					current.head = line.slice("HEAD ".length);
				} else if (line.startsWith("branch ")) {
					// Convert refs/heads/main -> main
					current.branch = line
						.slice("branch ".length)
						.replace(/^refs\/heads\//, "");
				} else if (line === "bare") {
					current.bare = true;
				} else if (line === "detached") {
					current.detached = true;
				} else if (line === "") {
					if (current.path) worktrees.push(current);
					current = {};
				}
			}
			if (current.path) worktrees.push(current);
			return { success: true, data: worktrees };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle(
		"git:worktree:add",
		async (_event, directory, worktreePath, branch, isNewBranch) => {
			try {
				const args = ["worktree", "add"];
				if (isNewBranch) {
					args.push("-b", branch, worktreePath);
				} else {
					args.push(worktreePath, branch);
				}
				runGit(directory, args.join(" "), ["ignore", "pipe", "pipe"]);
				return { success: true, data: { path: worktreePath } };
			} catch (err) {
				return { success: false, error: err.message ?? String(err) };
			}
		},
	);

	ipcMain.handle(
		"git:worktree:remove",
		async (_event, directory, worktreePath) => {
			try {
				runGit(directory, `worktree remove "${worktreePath}"`, [
					"ignore",
					"pipe",
					"pipe",
				]);
				return { success: true };
			} catch (err) {
				return { success: false, error: err.message ?? String(err) };
			}
		},
	);

	// -----------------------------------------------------------------------
	// Worktree setup detection & execution
	// -----------------------------------------------------------------------

	ipcMain.handle("worktree:detect-setup", async (_event, worktreePath) => {
		try {
			const checks = [
				{ file: "bun.lockb", cmd: "bun install" },
				{ file: "bun.lock", cmd: "bun install" },
				{ file: "pnpm-lock.yaml", cmd: "pnpm install" },
				{ file: "yarn.lock", cmd: "yarn install" },
				{ file: "package-lock.json", cmd: "npm install" },
				{ file: "package.json", cmd: "bun install" },
				{ file: "Cargo.toml", cmd: "cargo build" },
				{ file: "go.mod", cmd: "go mod download" },
				{ file: "pyproject.toml", cmd: "uv sync" },
				{ file: "requirements.txt", cmd: "pip install -r requirements.txt" },
			];
			for (const { file, cmd } of checks) {
				if (existsSync(join(worktreePath, file))) {
					return { detected: true, command: cmd, file };
				}
			}
			return { detected: false };
		} catch (err) {
			return { detected: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle(
		"worktree:run-setup",
		async (_event, worktreePath, command) => {
			try {
				execSync(command, {
					cwd: worktreePath,
					encoding: "utf-8",
					stdio: "pipe",
					timeout: 120_000,
				});
				return { success: true };
			} catch (err) {
				return {
					success: false,
					error: err.stderr || err.message || String(err),
				};
			}
		},
	);

	ipcMain.handle("git:merge", async (_event, directory, branch) => {
		try {
			runGit(directory, `merge "${branch}" --no-edit`, [
				"ignore",
				"pipe",
				"pipe",
			]);
			return { success: true };
		} catch (err) {
			// Check if it's a merge conflict (vs other errors)
			try {
				const conflicted = runGit(directory, "diff --name-only --diff-filter=U")
					.split(/\r?\n/)
					.map((f) => f.trim())
					.filter(Boolean);
				if (conflicted.length > 0) {
					return { success: false, conflicts: conflicted };
				}
			} catch {
				// Could not determine conflicts
			}
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("git:merge:abort", async (_event, directory) => {
		try {
			runGit(directory, "merge --abort", ["ignore", "pipe", "pipe"]);
			return { success: true };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});

	ipcMain.handle("git:remote:url", async (_event, directory) => {
		try {
			const url = runGit(directory, "remote get-url origin").trim();
			return { success: true, data: url };
		} catch (err) {
			return { success: false, error: err.message ?? String(err) };
		}
	});
}