Record your screen, ship a demo. Free and open-source, GPU-accelerated, no watermarks, no subscriptions. Windows, macOS, Linux. Actively maintained.
TypeScript cross-platformelectronffmpegopen-sourceproduct-demorustscreen-capturescreen-recorderscreen-recordingscreen-studioscreencastspeech-to-texttypescriptvideo-editingvideo-editorwaylandwgpuwhisper
import { contextBridge, ipcRenderer, sharedTexture, webUtils } from "electron";
import type { NativeLinuxRecordingRequest } from "../src/lib/nativeLinuxRecording";
import type { NativeMacRecordingRequest } from "../src/lib/nativeMacRecording";
import type { NativeWindowsRecordingRequest } from "../src/lib/nativeWindowsRecording";
import type { RecordingSession, StoreRecordedSessionInput } from "../src/lib/recordingSession";
import type { ShortcutBinding } from "../src/lib/shortcuts";
import type {
AiEditionChatEvent,
AiEditionMcpHostRequest,
AiEditionMcpHostResponse,
CompositorSharedFrameMeta,
} from "../src/native/contracts";
import {
AI_EDITION_MCP_HOST_CHANNEL,
AI_EDITION_MCP_REQUEST_CHANNEL,
AI_EDITION_MCP_RESPONSE_CHANNEL,
AI_EDITION_OPEN_PROJECT_CHANNEL,
NATIVE_BRIDGE_CHANNEL,
type NativeBridgeRequest,
} from "../src/native/contracts";
import type { UpdateBadge } from "./background-update";
import type { RecordingPrefs } from "./ipc/handlers";
import type {
SttStatusEvent,
SttTranscribeRequest,
SttTranscribeResponse,
} from "./stt/transcriptionContract";
// Asset base URL is passed from the main process via webPreferences.additionalArguments
// (see windows.ts). Sandboxed preloads cannot import node:path / node:url, so we
// can't compute it here.
const ASSET_BASE_URL_ARG_PREFIX = "--asset-base-url=";
const assetBaseUrlArg = process.argv.find((arg) => arg.startsWith(ASSET_BASE_URL_ARG_PREFIX));
const assetBaseUrl = assetBaseUrlArg ? assetBaseUrlArg.slice(ASSET_BASE_URL_ARG_PREFIX.length) : "";
// Renderer side: process.platform is the same Node global as in the main process,
// so a synchronous read here saves the renderer's every-call IPC round-trip.
const PLATFORM = process.platform;
// Preview frames the main process hands over as shared GPU textures (see
// `compositorViewService`). Electron gives up on a send after 1 s without a receiver, so it is
// registered here, at load, and forwards to whichever listener the page has set.
type CompositorFrameListener = (frame: VideoFrame, meta: CompositorSharedFrameMeta) => void;
let compositorFrameListener: CompositorFrameListener | null = null;
sharedTexture?.setSharedTextureReceiver(async ({ importedSharedTexture }, meta) => {
const frame = importedSharedTexture.getVideoFrame();
try {
compositorFrameListener?.(frame, meta as CompositorSharedFrameMeta);
} finally {
// The page drew from its own copy (contextBridge clones the frame) and closed it. Closing
// ours and releasing the import is what lets the native ring write the slot again.
frame.close();
importedSharedTexture.release();
}
});
contextBridge.exposeInMainWorld("electronAPI", {
assetBaseUrl,
// The renderer's navigator.clipboard.writeText is denied by Electron's
// permission gate (clipboard-sanitized-write), which left chat's Copy
// message permanently on its error toast (issue #738). Main's clipboard
// module has no such gate, so the write crosses here.
copyToClipboard: (text: string) =>
ipcRenderer.invoke("clipboard:write-text", text) as Promise<void>,
// --- Native export encoder -------------------------------------------------
// The renderer composites and extracts frames but cannot spawn ffmpeg (it is
// sandboxed, deliberately), so frames cross to main and it feeds ffmpeg's
// stdin. Frames go one-way via send(); flow control is the caller's credit
// window, acked on exportOnFrameAck.
exportCapabilities: () =>
ipcRenderer.invoke("export:capabilities") as Promise<{ encoder: string }>,
exportStart: (req: unknown) =>
ipcRenderer.invoke("export:start", req) as Promise<{
sessionId: string;
encoder: string;
outputPath: string;
}>,
exportWriteFrame: (sessionId: string, frame: ArrayBuffer) => {
// send() structured-clones, i.e. copies the frame. That is not an oversight
// and it is not fixable here: Electron's transfer list takes MessagePort[]
// only, and transferring an ArrayBuffer renderer->main silently drops the
// whole message (electron#34905 - it works renderer->renderer, not to main).
// The copy is what caps the crossing at ~390 MB/s, which is why the export
// ships NV12 (3.0 MB/frame) rather than BGRA (7.9 MB).
ipcRenderer.send("export:frame", sessionId, frame);
},
exportOnFrameAck: (cb: (sessionId: string, error: string | null) => void) => {
const handler = (_e: unknown, sessionId: string, error: string | null) => cb(sessionId, error);
ipcRenderer.on("export:frame-ack", handler);
return () => ipcRenderer.off("export:frame-ack", handler);
},
exportFinish: (sessionId: string) =>
ipcRenderer.invoke("export:finish", sessionId) as Promise<{ outputPath: string }>,
exportCancel: (sessionId: string) =>
ipcRenderer.invoke("export:cancel", sessionId) as Promise<void>,
/** Export bench only (--bench=): tells main the run is over so it can quit. */
benchFinished: () => ipcRenderer.invoke("bench:finished") as Promise<void>,
/** Native (D3D) export progress — frames encoded so far, pushed at ~10 Hz max while
* `compositor.export`/`compositor.exportMulti` runs. Distinct from `exportOnFrameAck`
* above, which is the OLD web/CPU pipeline's per-frame ack, not a progress signal. */
onNativeExportProgress: (cb: (frames: number, exportId?: string) => void) => {
const handler = (_e: unknown, frames: number, exportId?: string) => cb(frames, exportId);
ipcRenderer.on("export:native-progress", handler);
return () => ipcRenderer.off("export:native-progress", handler);
},
onCompositorFrame: (listener: CompositorFrameListener) => {
compositorFrameListener = listener;
return () => {
if (compositorFrameListener === listener) {
compositorFrameListener = null;
}
};
},
invokeNativeBridge: <TData>(request: NativeBridgeRequest) => {
return ipcRenderer.invoke(NATIVE_BRIDGE_CHANNEL, request) as Promise<TData>;
},
hudOverlayHide: () => {
ipcRenderer.send("hud-overlay-hide");
},
hudOverlayClose: () => {
ipcRenderer.send("hud-overlay-close");
},
setHudOverlayIgnoreMouseEvents: (ignore: boolean) => {
ipcRenderer.send("hud-overlay-ignore-mouse-events", ignore);
},
onHudOverlayCursor: (callback: (x: number, y: number) => void) => {
const listener = (_e: Electron.IpcRendererEvent, x: number, y: number) => callback(x, y);
ipcRenderer.on("hud-overlay-cursor", listener);
return () => ipcRenderer.removeListener("hud-overlay-cursor", listener);
},
beginHudOverlayDrag: () => {
ipcRenderer.send("hud-overlay-drag-start");
},
dragHudOverlayTo: (deltaX: number, deltaY: number) => {
ipcRenderer.send("hud-overlay-drag-to", deltaX, deltaY);
},
endHudOverlayDrag: () => {
ipcRenderer.send("hud-overlay-drag-end");
},
setHudOverlaySize: (
width: number,
height: number,
content: { x: number; y: number; width: number; height: number },
) => {
ipcRenderer.send("hud-overlay-set-size", width, height, content);
},
setHudOverlayContent: (content: { x: number; y: number; width: number; height: number }) => {
ipcRenderer.send("hud-overlay-content", content);
},
getSources: async (opts: Electron.SourcesOptions) => {
return await ipcRenderer.invoke("get-sources", opts);
},
switchToEditor: () => {
return ipcRenderer.invoke("switch-to-editor");
},
switchToHud: () => {
return ipcRenderer.invoke("switch-to-hud");
},
startNewRecording: () => {
return ipcRenderer.invoke("start-new-recording");
},
openSourceSelector: () => {
return ipcRenderer.invoke("open-source-selector");
},
usesSystemSourcePicker: (): Promise<boolean> => {
return ipcRenderer.invoke("uses-system-source-picker");
},
getLastPickedSource: (): Promise<string | null> => {
return ipcRenderer.invoke("get-last-picked-source");
},
openNotes: () => {
return ipcRenderer.invoke("open-notes");
},
selectSource: (source: ProcessedDesktopSource, options?: { persist?: boolean }) => {
return ipcRenderer.invoke("select-source", source, options);
},
getSelectedSource: () => {
return ipcRenderer.invoke("get-selected-source");
},
getRecordingPrefs: () => {
return ipcRenderer.invoke("get-recording-prefs");
},
setRecordingPrefs: (prefs: Partial<RecordingPrefs>) => {
return ipcRenderer.invoke("set-recording-prefs", prefs);
},
onRecordingPrefsChanged: (callback: (prefs: RecordingPrefs) => void) => {
const listener = (_event: unknown, prefs: RecordingPrefs) => callback(prefs);
ipcRenderer.on("recording-prefs-changed", listener);
return () => ipcRenderer.removeListener("recording-prefs-changed", listener);
},
onSelectedSourceChanged: (callback: (source: ProcessedDesktopSource | null) => void) => {
const listener = (_event: unknown, source: ProcessedDesktopSource | null) => callback(source);
ipcRenderer.on("selected-source-changed", listener);
return () => ipcRenderer.removeListener("selected-source-changed", listener);
},
onSourceSelectorClosed: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("source-selector-closed", listener);
return () => ipcRenderer.removeListener("source-selector-closed", listener);
},
onAutoStartRecording: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("hud-auto-start-recording", listener);
return () => ipcRenderer.removeListener("hud-auto-start-recording", listener);
},
requestCameraAccess: () => {
return ipcRenderer.invoke("request-camera-access");
},
permissions: {
get: () => ipcRenderer.invoke("permissions:get"),
request: (kind: string) => ipcRenderer.invoke("permissions:request", kind),
openSettings: (kind: string) => ipcRenderer.invoke("permissions:open-settings", kind),
relaunch: () => ipcRenderer.invoke("permissions:relaunch"),
close: () => ipcRenderer.invoke("permissions:close"),
},
requestNativeMacCursorAccess: () => {
return ipcRenderer.invoke("request-native-mac-cursor-access");
},
storeRecordedVideo: (videoData: ArrayBuffer, fileName: string) => {
return ipcRenderer.invoke("store-recorded-video", videoData, fileName);
},
storeRecordedSession: (payload: StoreRecordedSessionInput) => {
return ipcRenderer.invoke("store-recorded-session", payload);
},
openRecordingStream: (fileName: string) => {
return ipcRenderer.invoke("open-recording-stream", fileName);
},
appendRecordingChunk: (fileName: string, chunk: ArrayBuffer) => {
return ipcRenderer.invoke("append-recording-chunk", fileName, chunk);
},
closeRecordingStream: (fileName: string) => {
return ipcRenderer.invoke("close-recording-stream", fileName);
},
getRecordedVideoPath: () => {
return ipcRenderer.invoke("get-recorded-video-path");
},
setRecordingState: (
recording: boolean,
recordingId?: number,
cursorCaptureMode?: import("../src/lib/recordingSession").CursorCaptureMode,
reserveOnly?: boolean,
) => {
return ipcRenderer.invoke(
"set-recording-state",
recording,
recordingId,
cursorCaptureMode,
reserveOnly,
);
},
isNativeWindowsCaptureAvailable: () => {
return ipcRenderer.invoke("is-native-windows-capture-available");
},
isNativeMacCaptureAvailable: () => {
return ipcRenderer.invoke("is-native-mac-capture-available");
},
isNativeLinuxCaptureAvailable: () => {
return ipcRenderer.invoke("is-native-linux-capture-available");
},
prepareNativeLinuxRecording: (request: NativeLinuxRecordingRequest) => {
return ipcRenderer.invoke("prepare-native-linux-recording", request);
},
cancelNativeLinuxPrepare: () => {
return ipcRenderer.invoke("cancel-native-linux-prepare");
},
startNativeLinuxRecording: (request: NativeLinuxRecordingRequest) => {
return ipcRenderer.invoke("start-native-linux-recording", request);
},
pauseNativeLinuxRecording: () => {
return ipcRenderer.invoke("pause-native-linux-recording");
},
resumeNativeLinuxRecording: () => {
return ipcRenderer.invoke("resume-native-linux-recording");
},
stopNativeLinuxRecording: (discard?: boolean) => {
return ipcRenderer.invoke("stop-native-linux-recording", discard);
},
attachNativeLinuxWebcamRecording: (payload: {
screenVideoPath: string;
recordingId: number;
webcam: { fileName: string; videoData: ArrayBuffer };
cursorCaptureMode?: import("../src/lib/recordingSession").CursorCaptureMode;
durationMs?: number;
webcamOffsetMs?: number;
}) => {
return ipcRenderer.invoke("attach-native-linux-webcam-recording", payload);
},
startNativeWindowsRecording: (request: NativeWindowsRecordingRequest) => {
return ipcRenderer.invoke("start-native-windows-recording", request);
},
stopNativeWindowsRecording: (discard?: boolean) => {
return ipcRenderer.invoke("stop-native-windows-recording", discard);
},
pauseNativeWindowsRecording: () => {
return ipcRenderer.invoke("pause-native-windows-recording");
},
resumeNativeWindowsRecording: () => {
return ipcRenderer.invoke("resume-native-windows-recording");
},
startNativeMacRecording: (request: NativeMacRecordingRequest) => {
return ipcRenderer.invoke("start-native-mac-recording", request);
},
onNativeMacSystemAudioUnavailable: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("native-mac-system-audio-unavailable", listener);
return () => ipcRenderer.removeListener("native-mac-system-audio-unavailable", listener);
},
pauseNativeMacRecording: () => {
return ipcRenderer.invoke("pause-native-mac-recording");
},
resumeNativeMacRecording: () => {
return ipcRenderer.invoke("resume-native-mac-recording");
},
stopNativeMacRecording: (discard?: boolean) => {
return ipcRenderer.invoke("stop-native-mac-recording", discard);
},
attachNativeMacWebcamRecording: (payload: {
screenVideoPath: string;
recordingId: number;
webcam: { fileName: string; videoData: ArrayBuffer };
cursorCaptureMode?: import("../src/lib/recordingSession").CursorCaptureMode;
durationMs?: number;
webcamOffsetMs?: number;
}) => {
return ipcRenderer.invoke("attach-native-mac-webcam-recording", payload);
},
getCursorTelemetry: (videoPath?: string) => {
return ipcRenderer.invoke("get-cursor-telemetry", videoPath);
},
discardCursorTelemetry: (recordingId: number) => {
return ipcRenderer.invoke("discard-cursor-telemetry", recordingId);
},
onStopRecordingFromTray: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("stop-recording-from-tray", listener);
return () => ipcRenderer.removeListener("stop-recording-from-tray", listener);
},
openExternalUrl: (url: string) => {
return ipcRenderer.invoke("open-external-url", url);
},
// The star ask. The renderer reports that an export finished and is told yes or no; the
// counters, the take flag and the install channel stay in the main process.
openRepoPage: () => {
return ipcRenderer.invoke("star-prompt:open-repo");
},
starPromptExportFinished: () => {
return ipcRenderer.invoke("star-prompt:export-finished");
},
dismissStarPrompt: () => {
return ipcRenderer.invoke("star-prompt:dismiss");
},
// No URL argument on purpose: main builds the `ms-windows-store:` link from a constant.
openStoreReview: () => {
return ipcRenderer.invoke("star-prompt:open-store-review");
},
pickExportSavePath: (fileName: string, exportFolder?: string) => {
return ipcRenderer.invoke("pick-export-save-path", fileName, exportFolder);
},
writeExportToPath: (videoData: ArrayBuffer, filePath: string) => {
return ipcRenderer.invoke("write-export-to-path", videoData, filePath);
},
openVideoFilePicker: () => {
return ipcRenderer.invoke("open-video-file-picker");
},
openAudioFilePicker: () => {
return ipcRenderer.invoke("open-audio-file-picker");
},
saveRecordedVoiceover: (data: ArrayBuffer) => {
return ipcRenderer.invoke("save-recorded-voiceover", data);
},
stageClickSoundHit: (name: string, data: ArrayBuffer) => {
return ipcRenderer.invoke("stage-click-sound-hit", name, data);
},
setCurrentVideoPath: (path: string) => {
return ipcRenderer.invoke("set-current-video-path", path);
},
setCurrentRecordingSession: (session: RecordingSession | null) => {
return ipcRenderer.invoke("set-current-recording-session", session);
},
getCurrentVideoPath: () => {
return ipcRenderer.invoke("get-current-video-path");
},
getCurrentRecordingSession: () => {
return ipcRenderer.invoke("get-current-recording-session");
},
findRecordingCamera: (videoPath: string) => {
return ipcRenderer.invoke("find-recording-camera", videoPath);
},
readBinaryFile: (filePath: string) => {
return ipcRenderer.invoke("read-binary-file", filePath);
},
getReadableFileInfo: (filePath: string) => {
return ipcRenderer.invoke("get-readable-file-info", filePath);
},
/** Native waveform peaks, disk-cached. See electron/media/audioPeaks.ts. */
getAudioPeaks: (filePath: string, durationSec: number) => {
return ipcRenderer.invoke("get-audio-peaks", filePath, durationSec);
},
readFileChunk: (filePath: string, offset: number, length: number) => {
return ipcRenderer.invoke("read-file-chunk", filePath, offset, length);
},
preparePreviewAudioTrack: (filePath: string) => {
return ipcRenderer.invoke("prepare-preview-audio-track", filePath);
},
/** Loudness-normalisation gain the export applies to a voice file. See the handler. */
getLoudnessGain: (filePath: string) => {
return ipcRenderer.invoke("get-loudness-gain", filePath);
},
clearCurrentVideoPath: () => {
return ipcRenderer.invoke("clear-current-video-path");
},
saveProjectFile: (projectData: unknown, suggestedName?: string, existingProjectPath?: string) => {
return ipcRenderer.invoke("save-project-file", projectData, suggestedName, existingProjectPath);
},
loadProjectFile: (projectFolder?: string) => {
return ipcRenderer.invoke("load-project-file", projectFolder);
},
loadProjectFileFromPath: (filePath: string) => {
return ipcRenderer.invoke("load-project-file-from-path", filePath);
},
getPathForFile: (file: File) => {
try {
return webUtils.getPathForFile(file);
} catch {
return "";
}
},
loadCurrentProjectFile: () => {
return ipcRenderer.invoke("load-current-project-file");
},
onMenuNewProject: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-new-project", listener);
return () => ipcRenderer.removeListener("menu-new-project", listener);
},
onMenuImportVideo: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-import-video", listener);
return () => ipcRenderer.removeListener("menu-import-video", listener);
},
onMenuLoadProject: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-load-project", listener);
return () => ipcRenderer.removeListener("menu-load-project", listener);
},
onMenuSaveProject: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-save-project", listener);
return () => ipcRenderer.removeListener("menu-save-project", listener);
},
onMenuSaveProjectAs: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-save-project-as", listener);
return () => ipcRenderer.removeListener("menu-save-project-as", listener);
},
// The Edit menu's Undo/Redo. On macOS this is the ONLY way Cmd+Z reaches the
// renderer: AppKit matches the menu's key equivalent before the key event is
// delivered to the web contents, so the document-level keydown handler never
// runs. See `electron/edit-menu.ts`.
onMenuUndo: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-undo", listener);
return () => ipcRenderer.removeListener("menu-undo", listener);
},
onMenuRedo: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("menu-redo", listener);
return () => ipcRenderer.removeListener("menu-redo", listener);
},
quitApp: () => {
ipcRenderer.send("app-quit");
},
setTitleBarOverlay: (color: string, symbolColor: string) => {
ipcRenderer.send("set-titlebar-overlay", color, symbolColor);
},
getPlatform: () => PLATFORM,
/** The OS version, as the main process reads it: "14.6.1" on macOS, not the Darwin
* kernel's "23.6.0" that `os.release()` gives. Part of the sandboxed preload's `process`. */
getSystemVersion: () => process.getSystemVersion(),
/** App identity for the HUD's settings panel: the running version, and whether this copy
* may offer an update check at all — a Store/Flathub/Snap/Nix install may not, see
* electron/install-channel.ts. */
getAppInfo: () =>
ipcRenderer.invoke("get-app-info") as Promise<{
version: string;
canCheckForUpdates: boolean;
}>,
/** Resolves once the check has a verdict. The dialogs that verdict leads to — download,
* restart — are the main process's conversation, not the caller's. */
checkForUpdates: () => ipcRenderer.invoke("check-for-updates") as Promise<void>,
/** Opens the main process's About box (or the native panel on macOS). Resolves as soon as
* the box is up, NOT when it is dismissed — there is no verdict to wait for, unlike
* `checkForUpdates` above. */
showAbout: () => ipcRenderer.invoke("show-about") as Promise<void>,
/** The full update veto, asked fresh. `getAppInfo().canCheckForUpdates` answers only the
* permanent half; this one also answers "not mid-take", so it is only correct for a caller
* that asks at the moment it shows the affordance. */
canCheckForUpdatesNow: () => ipcRenderer.invoke("can-check-for-updates-now") as Promise<boolean>,
/** The update button's state: null hides it. Found by the main process's background check. */
getUpdateBadge: () => ipcRenderer.invoke("get-update-badge") as Promise<UpdateBadge | null>,
onUpdateBadgeChanged: (callback: (badge: UpdateBadge | null) => void) => {
const listener = (_event: unknown, badge: UpdateBadge | null) => callback(badge);
ipcRenderer.on("update-badge-changed", listener);
return () => ipcRenderer.removeListener("update-badge-changed", listener);
},
/** The button's click. Resolves at once; the dialogs or the restart that follow are the main
* process's. */
applyUpdate: () => ipcRenderer.invoke("apply-update") as Promise<void>,
revealInFolder: (filePath: string) => {
return ipcRenderer.invoke("reveal-in-folder", filePath);
},
checkRecordingStorage: () => {
return ipcRenderer.invoke("check-recording-storage") as Promise<
{ success: true } | { success: false; error: string }
>;
},
getRecordingsDir: () => {
return ipcRenderer.invoke("get-recordings-dir") as Promise<{
path: string;
isDefault: boolean;
}>;
},
chooseRecordingsDir: () => {
return ipcRenderer.invoke("choose-recordings-dir") as Promise<
{ success: true; path: string } | { success: false; canceled?: boolean; message?: string }
>;
},
resetRecordingsDir: () => {
return ipcRenderer.invoke("reset-recordings-dir") as Promise<
{ success: true; path: string } | { success: false; message?: string }
>;
},
getShortcuts: () => {
return ipcRenderer.invoke("get-shortcuts");
},
saveShortcuts: (shortcuts: unknown) => {
return ipcRenderer.invoke("save-shortcuts", shortcuts);
},
updateGlobalShortcut: (binding: ShortcutBinding) => {
return ipcRenderer.invoke("update-global-shortcut", binding);
},
setLocale: (locale: string) => {
return ipcRenderer.invoke("set-locale", locale);
},
saveDiagnostic: (payload: {
error: string;
stack?: string;
projectState: unknown;
logs: string[];
}) => {
return ipcRenderer.invoke("save-diagnostic", payload);
},
setMicrophoneExpanded: (expanded: boolean) => {
ipcRenderer.send("hud:setMicrophoneExpanded", expanded);
},
setHasUnsavedChanges: (hasChanges: boolean) => {
ipcRenderer.send("set-has-unsaved-changes", hasChanges);
},
showCountdownOverlay: (value: number, runId: number) => {
return ipcRenderer.invoke("countdown-overlay-show", value, runId);
},
setCountdownOverlayValue: (value: number, runId: number) => {
return ipcRenderer.invoke("countdown-overlay-set-value", value, runId);
},
hideCountdownOverlay: (runId: number) => {
return ipcRenderer.invoke("countdown-overlay-hide", runId);
},
onCountdownOverlayValue: (callback: (value: number | null, runId: number) => void) => {
const listener = (_event: unknown, value: number | null, runId: number) =>
callback(value, runId);
ipcRenderer.on("countdown-overlay-value", listener);
return () => ipcRenderer.removeListener("countdown-overlay-value", listener);
},
notifyCountdownOverlayCleared: (runId: number) => {
ipcRenderer.send("countdown-overlay-cleared", runId);
},
onRequestSaveBeforeClose: (callback: () => Promise<boolean> | boolean) => {
const listener = async () => {
try {
const shouldClose = await callback();
ipcRenderer.send("save-before-close-done", shouldClose);
} catch {
ipcRenderer.send("save-before-close-done", false);
}
};
ipcRenderer.on("request-save-before-close", listener);
return () => ipcRenderer.removeListener("request-save-before-close", listener);
},
onRequestCloseConfirm: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("request-close-confirm", listener);
return () => ipcRenderer.removeListener("request-close-confirm", listener);
},
sendCloseConfirmResponse: (choice: "save" | "discard" | "cancel") => {
ipcRenderer.send("close-confirm-response", choice);
},
// ponytail: forward renderer console output to main-process stdout so
// recorder diagnostics land next to the main-process logs in dev output.
// One-way fire-and-forget; we deliberately don't await the IPC.
rendererConsole: (channel: "log" | "warn" | "error", args: unknown[]) => {
ipcRenderer.send(`renderer-console-${channel}`, ...args);
},
onAiEditionChatEvent: (callback: (event: AiEditionChatEvent) => void) => {
const listener = (_e: unknown, payload: AiEditionChatEvent) => callback(payload);
ipcRenderer.on("ai-edition.chat-event", listener);
return () => ipcRenderer.removeListener("ai-edition.chat-event", listener);
},
// The editor answers the MCP server's reads and writes of the live document.
// Subscribing is what makes this window the one the server asks; the
// returned unsubscribe withdraws it. See electron/mcp/editor-document-host.ts.
onAiEditionMcpRequest: (
callback: (request: AiEditionMcpHostRequest) => Promise<AiEditionMcpHostResponse["result"]>,
) => {
const listener = (_e: unknown, request: AiEditionMcpHostRequest) => {
void callback(request).then(
(result) =>
ipcRenderer.send(AI_EDITION_MCP_RESPONSE_CHANNEL, {
requestId: request.requestId,
result,
}),
() =>
ipcRenderer.send(AI_EDITION_MCP_RESPONSE_CHANNEL, {
requestId: request.requestId,
result: null,
}),
);
};
ipcRenderer.on(AI_EDITION_MCP_REQUEST_CHANNEL, listener);
ipcRenderer.send(AI_EDITION_MCP_HOST_CHANNEL, true);
return () => {
ipcRenderer.removeListener(AI_EDITION_MCP_REQUEST_CHANNEL, listener);
ipcRenderer.send(AI_EDITION_MCP_HOST_CHANNEL, false);
};
},
// The project the editor holds, for `openscreen mcp` in another process (#1138).
setAiEditionOpenProject: (projectId: string | null) => {
ipcRenderer.send(AI_EDITION_OPEN_PROJECT_CHANNEL, projectId);
},
stt: {
transcribe: (request: SttTranscribeRequest): Promise<SttTranscribeResponse> => {
return ipcRenderer.invoke("stt:transcribe", request) as Promise<SttTranscribeResponse>;
},
/** Stop the running transcription at its next chunk boundary. */
cancel: (): Promise<void> => ipcRenderer.invoke("stt:cancel") as Promise<void>,
onStatus: (callback: (event: SttStatusEvent) => void) => {
const listener = (_event: unknown, payload: SttStatusEvent) => callback(payload);
ipcRenderer.on("stt:status", listener);
return () => ipcRenderer.removeListener("stt:status", listener);
},
},
// --- CLI mode (hidden runner windows; see electron/cli/) ---
cliGetRequest: (): Promise<import("../src/lib/cliContracts").CliRequest> => {
return ipcRenderer.invoke("cli-get-request");
},
cliProgress: (progress: import("../src/lib/cliContracts").CliProgressEvent) => {
ipcRenderer.send("cli-progress", progress);
},
cliLog: (level: "info" | "error", message: string) => {
ipcRenderer.send("cli-log", level, message);
},
cliDone: (result: import("../src/lib/cliContracts").CliDoneResult) => {
return ipcRenderer.invoke("cli-done", result);
},
onCliStopRecording: (callback: () => void) => {
const listener = () => callback();
ipcRenderer.on("cli-stop-recording", listener);
return () => ipcRenderer.removeListener("cli-stop-recording", listener);
},
});