Skip to content

Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.

32.8 KB
Raw Blame
import { BrowserWindow, ipcMain, shell } from "electron";
import type { AiEditionChatEvent } from "../../src/native/contracts";
import {
	NATIVE_BRIDGE_CHANNEL,
	NATIVE_BRIDGE_VERSION,
	type NativeBridgeErrorCode,
	type NativeBridgeRequest,
	type NativeBridgeResponse,
	type NativePlatform,
	type ProjectFileResult,
	type ProjectPathResult,
} from "../../src/native/contracts";
import { type ChatEventSink, deleteProjectChat } from "../ai-edition/chat-service";
import type { DocumentService } from "../ai-edition/document-service";
import { StylePresetError, type StylePresetService } from "../ai-edition/style-preset-service";
import { isValidMcpPort } from "../mcp/mcp-settings-store";
import {
	type CursorTelemetryLoadResult,
	TelemetryCursorAdapter,
} from "../native-bridge/cursor/telemetryCursorAdapter";
import { AiEditionService } from "../native-bridge/services/aiEditionService";
import { CompositorViewService } from "../native-bridge/services/compositorViewService";
import { CursorService } from "../native-bridge/services/cursorService";
import { ProjectService } from "../native-bridge/services/projectService";
import { SystemService } from "../native-bridge/services/systemService";
import { createNativeBridgeState } from "../native-bridge/store";
import { ChatRuns } from "./chatRuns";
import { ExportJobs, isExportId } from "./exportJobs";

export interface NativeBridgeContext {
	getPlatform: () => NodeJS.Platform;
	getCurrentProjectPath: () => string | null;
	getCurrentVideoPath: () => string | null;
	saveProjectFile: (
		projectData: unknown,
		suggestedName?: string,
		existingProjectPath?: string,
		parent?: BrowserWindow | null,
	) => Promise<ProjectFileResult>;
	loadProjectFile: (
		projectFolder?: string,
		parent?: BrowserWindow | null,
	) => Promise<ProjectFileResult>;
	loadCurrentProjectFile: () => Promise<ProjectFileResult>;
	loadProjectFileFromPath: (path: string) => Promise<ProjectFileResult>;
	setCurrentVideoPath: (path: string) => ProjectPathResult | Promise<ProjectPathResult>;
	getCurrentVideoPathResult: () => ProjectPathResult;
	clearCurrentVideoPath: () => ProjectPathResult;
	resolveAssetBasePath: () => string | null;
	resolveVideoPath: (videoPath?: string | null) => string | null;
	loadCursorRecordingData: (
		videoPath: string,
	) => Promise<import("../../src/native/contracts").CursorRecordingData>;
	loadCursorTelemetry: (videoPath: string) => Promise<CursorTelemetryLoadResult>;
	/**
	 * returns the native (HWND / NSView / xcb_window) handle buffer
	 * for the BrowserWindow that hosts the requesting renderer. Used by the
	 * compositor domain's `createView` to wire the embedded native window
	 * to its D3D11 parent. May return `null` if the sender has no live window
	 * (e.g. mid-teardown), in which case `createView` fails with UNAVAILABLE.
	 */
	getNativeWindowHandle?: (sender: import("electron").WebContents) => Buffer | null;
	getAiEditionDocuments: () => DocumentService;
	/** OpenScreen's recordings folders, the current one first. Absent: deleting a project keeps its recordings. */
	getRecordingsDirs?: () => { dirs: string[]; registryDir: string };
	/** The one shared style preset service — it serialises writes per instance. */
	getStylePresets: () => StylePresetService;
	getAiEditionLlmConfig: () => import("../ai-edition/llm-config-store").LlmConfigStore;
	/** The local MCP server's controller. Absent in the headless CLI. */
	getMcpController?: () => import("../mcp/mcp-controller").McpController;
	runAiEditionChat: (
		projectId: string,
		sessionId: string,
		message: string,
		document?: unknown,
		sink?: ChatEventSink,
		signal?: AbortSignal,
	) => Promise<import("../../src/native/contracts").AiEditionChatResult>;
	undoAiEditionToolBatch: (
		projectId: string,
		sessionId: string,
	) => import("../../src/native/contracts").AiEditionChatResult;
	rewindToMessage: (
		projectId: string,
		sessionId: string,
		messageId: string,
	) =>
		| {
				success: true;
				prompt: string;
				document: unknown;
				messages: import("../../src/native/contracts").AiEditionChatMessage[];
		  }
		| { success: false; error: string };
	compactNow: (
		projectId: string,
		sessionId: string,
	) => Promise<import("../../src/native/contracts").AiEditionChatCompactResult | null>;
	getContextUsage: (
		projectId: string,
		sessionId: string,
	) => import("../../src/native/contracts").AiEditionChatBudget | null;
	listAiEditionChatSessions: (
		projectId: string,
	) => import("../../src/native/contracts").AiEditionChatSessionSummary[];
	createAiEditionChatSession: (
		projectId: string,
		title?: string,
	) => import("../../src/native/contracts").AiEditionChatSessionSummary;
	selectAiEditionChatSession: (
		projectId: string,
		sessionId: string,
	) => import("../../src/native/contracts").AiEditionChatSession | null;
	renameAiEditionChatSession: (
		projectId: string,
		sessionId: string,
		title: string,
	) => import("../../src/native/contracts").AiEditionChatSessionSummary | null;
	deleteAiEditionChatSession: (projectId: string, sessionId: string) => boolean;
}

function normalizePlatform(platform: NodeJS.Platform): NativePlatform {
	if (platform === "darwin" || platform === "win32") {
		return platform;
	}

	return "linux";
}

function createMeta(requestId?: string) {
	return {
		version: NATIVE_BRIDGE_VERSION,
		requestId: requestId || `native-${Date.now()}`,
		timestampMs: Date.now(),
	} as const;
}

function createSuccessResponse<TData>(requestId: string | undefined, data: TData) {
	return {
		ok: true,
		data,
		meta: createMeta(requestId),
	} satisfies NativeBridgeResponse<TData>;
}

function createErrorResponse(
	requestId: string | undefined,
	code: NativeBridgeErrorCode,
	message: string,
	retryable = false,
) {
	return {
		ok: false,
		error: {
			code,
			message,
			retryable,
		},
		meta: createMeta(requestId),
	} satisfies NativeBridgeResponse;
}

/**
 * Strips absolute filesystem paths out of an error message before it crosses to
 * the renderer. Main-process errors quote the path they failed on (`ENOENT: no
 * such file or directory, open 'C:\Users\alice\…'`), and that string is rendered
 * verbatim in toasts and the chat error rail. Keeps the basename, which is the
 * part a user can act on. The full message still goes to the main-process log.
 */
function redactPaths(message: string): string {
	return message
		.replace(/[A-Za-z]:\\(?:[^\\/:*?"<>|\r\n]+\\)*([^\\/:*?"<>|\r\n]*)/g, "…\\$1")
		.replace(/\/(?:[^/\0\s'"]+\/)+([^/\0\s'"]*)/g, "…/$1");
}

function isBridgeRequest(value: unknown): value is NativeBridgeRequest {
	if (!value || typeof value !== "object") {
		return false;
	}

	const candidate = value as Partial<NativeBridgeRequest>;
	return typeof candidate.domain === "string" && typeof candidate.action === "string";
}

// Route progress only to the requesting renderer and only while its turn is
// active. Window teardown aborts the run; a send racing teardown is harmless.
function buildChatEventSink(
	sender: Electron.WebContents,
	projectId: string,
	sessionId: string,
	runId: string,
	signal: AbortSignal,
): ChatEventSink {
	const identity = { projectId, runId };
	const send = (payload: AiEditionChatEvent) => {
		try {
			if (!signal.aborted) sender.send("ai-edition.chat-event", payload);
		} catch {
			// webContents gone — keep the loop running silently.
		}
	};
	return {
		document: (document) => send({ ...identity, kind: "document", sessionId, document }),
		text: (delta) => send({ ...identity, kind: "text", sessionId, delta }),
		thinking: (delta) => send({ ...identity, kind: "thinking", sessionId, delta }),
		toolStart: (name, args) => send({ ...identity, kind: "toolStart", sessionId, name, args }),
		toolEnd: (name, ok, summary) =>
			send({ ...identity, kind: "toolEnd", sessionId, name, ok, summary }),
		error: (message) => send({ ...identity, kind: "error", sessionId, message }),
	};
}

export function registerNativeBridgeHandlers(context: NativeBridgeContext) {
	ipcMain.removeHandler(NATIVE_BRIDGE_CHANNEL);

	const platform = normalizePlatform(context.getPlatform());
	const store = createNativeBridgeState(platform);
	const projectService = new ProjectService({
		store,
		getCurrentProjectPath: context.getCurrentProjectPath,
		getCurrentVideoPath: context.getCurrentVideoPath,
		saveProjectFile: context.saveProjectFile,
		loadProjectFile: context.loadProjectFile,
		loadCurrentProjectFile: context.loadCurrentProjectFile,
		loadProjectFileFromPath: context.loadProjectFileFromPath,
		setCurrentVideoPath: context.setCurrentVideoPath,
		getCurrentVideoPathResult: context.getCurrentVideoPathResult,
		clearCurrentVideoPath: context.clearCurrentVideoPath,
	});
	const cursorService = new CursorService({
		store,
		adapter: new TelemetryCursorAdapter({
			loadRecordingData: context.loadCursorRecordingData,
			resolveVideoPath: context.resolveVideoPath,
			loadTelemetry: context.loadCursorTelemetry,
		}),
	});
	const systemService = new SystemService({
		store,
		getPlatform: () => platform,
		getAssetBasePath: context.resolveAssetBasePath,
		getCursorCapabilities: () => cursorService.getCapabilities(),
	});
	const compositorViewService = new CompositorViewService();
	const aiEditionService = new AiEditionService({
		documents: context.getAiEditionDocuments(),
		deleteChatHistory: deleteProjectChat,
		// Passed uncalled on purpose — invoking it here would build the store (and
		// hit the macOS Keychain) while wiring the bridge at startup.
		llmConfig: context.getAiEditionLlmConfig,
		mcp: context.getMcpController?.(),
		recordings: context.getRecordingsDirs
			? {
					dirs: () => context.getRecordingsDirs?.().dirs ?? [],
					registryDir: () => context.getRecordingsDirs?.().registryDir ?? "",
					trashItem: (filePath) => shell.trashItem(filePath),
				}
			: undefined,
		runChat: context.runAiEditionChat,
		undoLastToolBatch: context.undoAiEditionToolBatch,
		rewindToMessage: context.rewindToMessage,
		compactNow: context.compactNow,
		getContextUsage: context.getContextUsage,
		listSessions: context.listAiEditionChatSessions,
		createSession: context.createAiEditionChatSession,
		selectSession: context.selectAiEditionChatSession,
		renameSession: context.renameAiEditionChatSession,
		deleteSession: context.deleteAiEditionChatSession,
	});

	const exportJobs = new ExportJobs();
	const chatRuns = new ChatRuns<Electron.WebContents>();
	ipcMain.handle(NATIVE_BRIDGE_CHANNEL, async (event, request: unknown) => {
		if (!isBridgeRequest(request)) {
			return createErrorResponse(undefined, "INVALID_REQUEST", "Invalid native bridge request.");
		}

		const requestId = request.requestId;
		const domain = request.domain as string;

		try {
			switch (request.domain) {
				case "system": {
					const action = request.action as string;
					switch (request.action) {
						case "getPlatform":
							return createSuccessResponse(requestId, systemService.getPlatform());
						case "getAssetBasePath":
							return createSuccessResponse(requestId, systemService.getAssetBasePath());
						case "getCapabilities":
							return createSuccessResponse(requestId, await systemService.getCapabilities());
						default:
							return createErrorResponse(
								requestId,
								"UNSUPPORTED_ACTION",
								`Unsupported system action: ${action}`,
							);
					}
				}

				case "project": {
					const action = request.action as string;
					switch (request.action) {
						case "getCurrentContext":
							return createSuccessResponse(requestId, projectService.getCurrentContext());
						case "saveProjectFile":
							return createSuccessResponse(
								requestId,
								await projectService.saveProjectFile(
									request.payload.projectData,
									request.payload.suggestedName,
									request.payload.existingProjectPath,
									BrowserWindow.fromWebContents(event.sender),
								),
							);
						case "loadProjectFile":
							return createSuccessResponse(
								requestId,
								await projectService.loadProjectFile(
									request.payload?.projectFolder,
									BrowserWindow.fromWebContents(event.sender),
								),
							);
						case "loadCurrentProjectFile":
							return createSuccessResponse(
								requestId,
								await projectService.loadCurrentProjectFile(),
							);
						case "loadProjectFileFromPath":
							return createSuccessResponse(
								requestId,
								await projectService.loadProjectFileFromPath(request.payload.path),
							);
						case "setCurrentVideoPath":
							return createSuccessResponse(
								requestId,
								await projectService.setCurrentVideoPath(request.payload.path),
							);
						case "getCurrentVideoPath":
							return createSuccessResponse(requestId, projectService.getCurrentVideoPath());
						case "clearCurrentVideoPath":
							return createSuccessResponse(requestId, projectService.clearCurrentVideoPath());
						default:
							return createErrorResponse(
								requestId,
								"UNSUPPORTED_ACTION",
								`Unsupported project action: ${action}`,
							);
					}
				}

				case "cursor": {
					const action = request.action as string;
					switch (request.action) {
						case "getCapabilities":
							return createSuccessResponse(requestId, await cursorService.getCapabilities());
						case "getTelemetry":
							return createSuccessResponse(
								requestId,
								await cursorService.getTelemetry(request.payload?.videoPath),
							);
						case "getRecordingData":
							return createSuccessResponse(
								requestId,
								await cursorService.getRecordingData(request.payload?.videoPath),
							);
						default:
							return createErrorResponse(
								requestId,
								"UNSUPPORTED_ACTION",
								`Unsupported cursor action: ${action}`,
							);
					}
				}

				case "compositor": {
					const action = request.action as string;
					switch (request.action) {
						case "createView": {
							const id = compositorViewService.createView(request.payload.rect, {
								screenPath: request.payload.screenPath,
								webcamPath: request.payload.webcamPath,
								cursorPath: request.payload.cursorPath,
							});
							return createSuccessResponse(requestId, { id });
						}
						case "probeBackend":
							// No view needed: the export dialog asks before any preview exists.
							return createSuccessResponse(requestId, {
								backend: compositorViewService.probeBackend(),
							});
						case "probeSegmentation":
							// No view needed either: the layout panel decides whether to offer the
							// camera-background control before any preview exists.
							return createSuccessResponse(requestId, {
								support: compositorViewService.probeSegmentation(),
							});
						case "segmentFrame":
							return createSuccessResponse(requestId, {
								mask: await compositorViewService.segmentFrame(request.payload.rgba),
							});
						case "checkShaderEffect":
							// The inspector shows why an effect does not draw on this machine.
							return createSuccessResponse(requestId, {
								check: await compositorViewService.checkShaderEffect(
									request.payload.code,
									request.payload.params,
								),
							});
						case "setRect":
							compositorViewService.setRect(request.payload.id, request.payload.rect);
							return createSuccessResponse(requestId, { ok: true });
						case "readFrame": {
							// The renderer polls this every rAF tick. It passes the generation it
							// last painted as `sinceGen`; native returns `null` when nothing newer
							// exists (idle path — no buffer copy). On a new frame it returns
							// `{ gen, width, height, data }`, or — for a view on shared textures —
							// sends the texture to the asking frame and returns its receipt. The
							// response wrapper does NOT JSON-stringify — `ipcMain.handle` round-trips
							// via structured clone, which preserves the nested `Buffer` as binary.
							const frame = await compositorViewService.readFrame(
								request.payload.id,
								request.payload.sinceGen,
								event.senderFrame,
							);
							return createSuccessResponse(requestId, frame);
						}
						case "stopSharedFrames":
							compositorViewService.stopSharedFrames(request.payload.id);
							return createSuccessResponse(requestId, { ok: true });
						case "setParam":
							compositorViewService.setParam(
								request.payload.id,
								request.payload.key,
								request.payload.value,
							);
							return createSuccessResponse(requestId, { ok: true });
						case "setPlaying":
							compositorViewService.setPlaying(request.payload.id, request.payload.playing);
							return createSuccessResponse(requestId, { ok: true });
						case "presentTime":
							compositorViewService.presentTime(request.payload.id, request.payload.seconds);
							return createSuccessResponse(requestId, { ok: true });
						case "setScene":
							compositorViewService.setScene(request.payload.id, request.payload.sceneJson);
							return createSuccessResponse(requestId, { ok: true });
						case "setActiveClip":
							compositorViewService.setActiveClip(
								request.payload.id,
								request.payload.screenPath,
								request.payload.webcamPath,
								request.payload.webcamOffsetSec,
								request.payload.clipIndex,
								request.payload.sourceTimeSec,
							);
							return createSuccessResponse(requestId, { ok: true });
						case "destroyView":
							compositorViewService.destroyView(request.payload.id);
							return createSuccessResponse(requestId, { ok: true });
						case "exportMulti": {
							const sender = event.sender;
							const exportId = request.payload?.exportId;
							if (exportId !== undefined && !isExportId(exportId)) {
								return createErrorResponse(requestId, "INVALID_REQUEST", "Invalid export ID.");
							}
							const onProgress = (frames: number) => {
								if (!sender.isDestroyed()) sender.send("export:native-progress", frames, exportId);
							};
							const stats = exportId
								? await exportJobs.run(
										sender,
										exportId,
										(progress) =>
											compositorViewService.startExportMulti(
												request.payload.clips,
												request.payload.outPath,
												request.payload.sceneJson,
												request.payload.params,
												progress,
											),
										onProgress,
									)
								: await compositorViewService.exportMulti(
										request.payload.clips,
										request.payload.outPath,
										request.payload.sceneJson,
										request.payload.params,
										onProgress,
									);
							if (!stats) {
								return createErrorResponse(
									requestId,
									"UNAVAILABLE",
									"Native compositor addon not present.",
								);
							}
							return createSuccessResponse(requestId, stats);
						}
						case "exportGif": {
							const sender = event.sender;
							const exportId = request.payload?.exportId;
							if (exportId !== undefined && !isExportId(exportId)) {
								return createErrorResponse(requestId, "INVALID_REQUEST", "Invalid export ID.");
							}
							const onProgress = (frames: number) => {
								if (!sender.isDestroyed()) sender.send("export:native-progress", frames, exportId);
							};
							const stats = exportId
								? await exportJobs.run(
										sender,
										exportId,
										(progress) =>
											compositorViewService.startGifExport(
												request.payload.clips,
												request.payload.outPath,
												request.payload.sceneJson,
												request.payload.params,
												progress,
											),
										onProgress,
									)
								: await compositorViewService.exportGif(
										request.payload.clips,
										request.payload.outPath,
										request.payload.sceneJson,
										request.payload.params,
										onProgress,
									);
							if (!stats) {
								return createErrorResponse(
									requestId,
									"UNAVAILABLE",
									"Native compositor addon not present.",
								);
							}
							return createSuccessResponse(requestId, stats);
						}
						case "cancelExport": {
							const exportId = request.payload?.exportId;
							if (!isExportId(exportId)) {
								return createErrorResponse(requestId, "INVALID_REQUEST", "Invalid export ID.");
							}
							return createSuccessResponse(requestId, {
								accepted: exportJobs.cancel(event.sender, exportId),
							});
						}
						default:
							return createErrorResponse(
								requestId,
								"UNSUPPORTED_ACTION",
								`Unsupported compositor action: ${action}`,
							);
					}
				}

				case "aiEdition": {
					const action = request.action as string;
					switch (request.action) {
						case "document.listProjects":
							return createSuccessResponse(requestId, await aiEditionService.listProjects());
						case "document.get":
							return createSuccessResponse(
								requestId,
								await aiEditionService.get(request.payload.projectId),
							);
						case "document.create":
							return createSuccessResponse(
								requestId,
								await aiEditionService.create(request.payload?.title),
							);
						case "document.save":
							return createSuccessResponse(
								requestId,
								await aiEditionService.save(request.payload.document),
							);
						// Renderer input: anything but "trash" would take the permanent path.
						case "document.delete": {
							const disposal: unknown = request.payload.recordings;
							if (
								disposal !== undefined &&
								disposal !== "keep" &&
								disposal !== "trash" &&
								disposal !== "permanent"
							) {
								return createErrorResponse(
									requestId,
									"INVALID_REQUEST",
									"Invalid recordings disposal.",
								);
							}
							return createSuccessResponse(
								requestId,
								await aiEditionService.deleteProject(request.payload.projectId, disposal),
							);
						}
						case "document.recordings":
							return createSuccessResponse(
								requestId,
								await aiEditionService.projectRecordings(request.payload.projectId),
							);
						case "document.addAsset":
							return createSuccessResponse(
								requestId,
								await aiEditionService.addAsset(
									request.payload.projectId,
									request.payload.path,
									request.payload.label,
									request.payload.kind,
								),
							);
						case "document.removeAsset":
							return createSuccessResponse(
								requestId,
								await aiEditionService.removeAsset(
									request.payload.projectId,
									request.payload.assetId,
								),
							);
						case "llm.getSnapshot":
							return createSuccessResponse(requestId, await aiEditionService.llmGetSnapshot());
						case "llm.setConfig":
							return createSuccessResponse(
								requestId,
								await aiEditionService.llmSetConfig(request.payload.config),
							);
						case "llm.setApiKey":
							return createSuccessResponse(
								requestId,
								await aiEditionService.llmSetApiKey(
									request.payload.providerId,
									request.payload.apiKey,
								),
							);
						case "llm.removeApiKey":
							return createSuccessResponse(
								requestId,
								await aiEditionService.llmRemoveApiKey(request.payload.providerId),
							);
						case "llm.disconnect":
							return createSuccessResponse(
								requestId,
								await aiEditionService.llmDisconnect(request.payload.providerId),
							);
						case "llm.listProviderModels":
							return createSuccessResponse(
								requestId,
								await aiEditionService.llmListProviderModels(request.payload.providerId),
							);
						case "mcp.getStatus":
							return createSuccessResponse(requestId, await aiEditionService.mcpGetStatus());
						// Renderer input: check the types here, so a bad value is reported as
						// the bad request it is rather than failing later as an internal error.
						case "mcp.setEnabled":
							if (typeof request.payload?.enabled !== "boolean") {
								return createErrorResponse(
									requestId,
									"INVALID_REQUEST",
									"Invalid MCP enabled flag.",
								);
							}
							return createSuccessResponse(
								requestId,
								await aiEditionService.mcpSetEnabled(request.payload.enabled),
							);
						case "mcp.setPort":
							if (!isValidMcpPort(request.payload?.port)) {
								return createErrorResponse(
									requestId,
									"INVALID_REQUEST",
									"MCP port must be a whole number between 1024 and 65535.",
								);
							}
							return createSuccessResponse(
								requestId,
								await aiEditionService.mcpSetPort(request.payload.port),
							);
						case "mcp.setAllowEdits":
							if (typeof request.payload?.allowEdits !== "boolean") {
								return createErrorResponse(
									requestId,
									"INVALID_REQUEST",
									"Invalid MCP edit permission.",
								);
							}
							return createSuccessResponse(
								requestId,
								await aiEditionService.mcpSetAllowEdits(request.payload.allowEdits),
							);
						case "mcp.regenerateToken":
							return createSuccessResponse(requestId, await aiEditionService.mcpRegenerateToken());
						case "chat.cancel":
						case "chat.run": {
							const payload = request.payload;
							const validId = (id: unknown): id is string =>
								typeof id === "string" && /^[A-Za-z0-9_-]{1,200}$/.test(id);
							if (
								!payload ||
								!validId(payload.projectId) ||
								!validId(payload.sessionId) ||
								!validId(payload.runId)
							) {
								return createErrorResponse(
									requestId,
									"INVALID_REQUEST",
									"Invalid chat turn identity.",
								);
							}
							const { projectId, sessionId, runId } = payload;
							if (request.action === "chat.cancel") {
								return createSuccessResponse(requestId, {
									accepted: chatRuns.cancel(event.sender, projectId, sessionId, runId),
								});
							}
							if (typeof request.payload.message !== "string" || !request.payload.message.trim()) {
								return createErrorResponse(requestId, "INVALID_REQUEST", "Invalid chat message.");
							}
							const documentProjectId = (
								request.payload.document as { project?: { id?: unknown } } | null
							)?.project?.id;
							if (documentProjectId !== undefined && documentProjectId !== projectId) {
								return createErrorResponse(
									requestId,
									"INVALID_REQUEST",
									"The document belongs to another project.",
								);
							}
							const turn = chatRuns.start(event.sender, projectId, sessionId, runId);
							if (!turn)
								return createErrorResponse(
									requestId,
									"UNAVAILABLE",
									"An agent turn is already running for this project.",
								);
							const abandon = () => chatRuns.cancel(event.sender, projectId, sessionId, runId);
							event.sender.once("destroyed", abandon);
							try {
								return createSuccessResponse(
									requestId,
									await aiEditionService.chatRun(
										projectId,
										sessionId,
										request.payload.message,
										request.payload.document,
										buildChatEventSink(event.sender, projectId, sessionId, runId, turn.signal),
										turn.signal,
									),
								);
							} finally {
								event.sender.removeListener("destroyed", abandon);
								turn.finish();
							}
						}
						case "chat.undoLastBatch":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatUndoLastBatch(
									request.payload.projectId,
									request.payload.sessionId,
								),
							);
						case "chat.listSessions":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatListSessions(request.payload.projectId),
							);
						case "chat.createSession":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatCreateSession(
									request.payload.projectId,
									request.payload.title,
								),
							);
						case "chat.selectSession":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatSelectSession(
									request.payload.projectId,
									request.payload.sessionId,
								),
							);
						case "chat.renameSession":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatRenameSession(
									request.payload.projectId,
									request.payload.sessionId,
									request.payload.title,
								),
							);
						case "chat.deleteSession":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatDeleteSession(
									request.payload.projectId,
									request.payload.sessionId,
								),
							);
						case "chat.budget":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatBudget(request.payload.projectId, request.payload.sessionId),
							);
						case "chat.compact":
							return createSuccessResponse(
								requestId,
								await aiEditionService.chatCompact(
									request.payload.projectId,
									request.payload.sessionId,
								),
							);
						case "chat.rewind":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatRewindToMessage(
									request.payload.projectId,
									request.payload.sessionId,
									request.payload.messageId,
								),
							);
						case "chat.contextUsage":
							return createSuccessResponse(
								requestId,
								aiEditionService.chatContextUsage(
									request.payload.projectId,
									request.payload.sessionId,
								),
							);
						case "chat.compactNow":
							return createSuccessResponse(
								requestId,
								await aiEditionService.chatCompactNow(
									request.payload.projectId,
									request.payload.sessionId,
								),
							);
						case "captions.translate":
							return createSuccessResponse(
								requestId,
								await aiEditionService.captionsTranslate({
									segments: request.payload.segments,
									targetLanguage: request.payload.targetLanguage,
									sourceLanguage: request.payload.sourceLanguage,
								}),
							);
						default:
							return createErrorResponse(
								requestId,
								"UNSUPPORTED_ACTION",
								`Unsupported aiEdition action: ${action}`,
							);
					}
				}

				case "presets": {
					const action = request.action as string;
					const presets = context.getStylePresets();
					switch (request.action) {
						case "list":
							return createSuccessResponse(requestId, await presets.list());
						case "create":
							return createSuccessResponse(
								requestId,
								await presets.create(request.payload.name, request.payload.appearance),
							);
						case "rename":
							return createSuccessResponse(
								requestId,
								await presets.rename(request.payload.id, request.payload.name),
							);
						case "update":
							return createSuccessResponse(
								requestId,
								await presets.update(request.payload.id, request.payload.appearance),
							);
						case "delete":
							await presets.delete(request.payload.id);
							return createSuccessResponse(requestId, { success: true });
						case "setForNewProjects":
							await presets.setForNewProjects(request.payload.id);
							return createSuccessResponse(requestId, { success: true });
						case "reveal": {
							// The path is built here from the id, never taken from the renderer.
							const target = await presets.revealTarget(request.payload.id);
							if (target.kind === "file") {
								shell.showItemInFolder(target.path);
							} else {
								const openError = await shell.openPath(target.path);
								if (openError) throw new Error(openError);
							}
							return createSuccessResponse(requestId, { success: true });
						}
						default:
							return createErrorResponse(
								requestId,
								"UNSUPPORTED_ACTION",
								`Unsupported presets action: ${action}`,
							);
					}
				}

				default:
					return createErrorResponse(
						requestId,
						"UNSUPPORTED_ACTION",
						`Unsupported bridge domain: ${domain}`,
					);
			}
		} catch (error) {
			if (
				request.domain === "compositor" &&
				error instanceof Error &&
				((request.action === "exportGif" && error.message === "GIF_EXPORT_CANCELLED") ||
					(request.action === "exportMulti" && error.message === "MP4_EXPORT_CANCELLED"))
			) {
				return createErrorResponse(requestId, "CANCELLED", "Export cancelled.");
			}
			// Not retryable by default: most failures here are permanent (a missing
			// file, a bad payload, an unavailable addon), and a blanket `true` tells
			// the client to spin on them. The message keeps the reason but drops any
			// absolute path — it crosses to the renderer and ends up in UI strings.
			console.error(`native bridge ${domain}.${request.action} failed:`, error);
			// Style preset failures the UI acts on keep their own code: a taken name is a
			// prompt to pick another, not a crash. A TypeError there is a preset or name that
			// failed validation, i.e. a bad request.
			if (error instanceof StylePresetError) {
				return createErrorResponse(
					requestId,
					error.code === "INVALID_ID" ? "INVALID_REQUEST" : error.code,
					redactPaths(error.message),
				);
			}
			if (domain === "presets" && error instanceof TypeError) {
				return createErrorResponse(requestId, "INVALID_REQUEST", redactPaths(error.message));
			}
			return createErrorResponse(
				requestId,
				"INTERNAL_ERROR",
				redactPaths(error instanceof Error ? error.message : "Unknown native bridge error."),
			);
		}
	});
}