IPC Channels: Electron Renderer-to-Main Communication

const ffmpegPath = await window.wzrdQcut.ffmpeg.getPath();
// → "/opt/homebrew/bin/ffmpeg"

interface FfmpegHealthResult {
  ffmpegOk: boolean;
  ffprobeOk: boolean;
  ffmpegVersion: string;    // e.g. "ffmpeg version 7.1"
  ffprobeVersion: string;
  ffmpegPath: string;
  ffprobePath: string;
  errors: string[];         // Non-empty only if not ok
}

const health = await window.wzrdQcut.ffmpeg.checkHealth();

const { sessionId, framesDir } = await window.wzrdQcut.ffmpeg.createExportSession();

await window.wzrdQcut.ffmpeg.saveFrame({
  sessionId,
  frameNumber: 42,
  imageData: uint8ArrayFromCanvas,
});
// → { success: true }

await window.wzrdQcut.ffmpeg.saveStickerForExport({
  sessionId,
  stickerId: 'emoji-fire',
  imageData: uint8Array,
  format: 'png',
});
// → { success: true, path: '.../stickers/emoji-fire.png' }

interface ExportVideoOptions {
  sessionId: string;
  width: number;
  height: number;
  fps: number;
  duration: number;
  quality?: 'high' | 'medium' | 'low';  // default: 'medium'
  // Video source (one of):
  useVideoInput?: boolean;
  videoInputPath?: string;
  videoSources?: Array<{ path: string; trimStart?: number; trimEnd?: number }>;
  // Overlays:
  filterChain?: string;
  textFilterChain?: string;
  imageFilterChain?: string;
  imageSources?: Array<{ path: string; duration: number }>;
  stickerFilterChain?: string;
  stickerSources?: Array<{ path: string; endTime: number }>;
  // Audio:
  audioFiles?: Array<{ path: string; startTime?: number; volume?: number }>;
  // Direct copy:
  useDirectCopy?: boolean;
}

const result = await window.wzrdQcut.ffmpeg.exportVideoCLI({
  sessionId,
  width: 1080,
  height: 1920,
  fps: 30,
  duration: 15,
  quality: 'high',
  videoInputPath: '/path/to/base.mp4',
});
// → { success: true, outputFile: '.../output/output.mp4' }
// → { success: false, error: '...', detail: '...' }

const { audioPath, fileSize } = await window.wzrdQcut.ffmpeg.extractAudio({
  videoPath: '/path/to/video.mp4',
  format: 'wav',  // 'wav' (default, PCM 16-bit 16 kHz mono) or 'mp3'
});

const buffer = await window.wzrdQcut.ffmpeg.readOutputFile('/path/to/output.mp4');

await window.wzrdQcut.ffmpeg.cleanupExportSession(sessionId);

await window.wzrdQcut.ffmpeg.openFramesFolder(sessionId);

interface PtySpawnOptions {
  shell?: string;    // Default: $SHELL or /bin/zsh
  command?: string;  // If provided, runs as: shell -lc "<command>"
  cwd?: string;      // Default: app.getPath('home')
  cols?: number;     // Default: 80
  rows?: number;     // Default: 24
  env?: Record<string, string>;  // Merged with process.env
}

const { success, sessionId } = await window.wzrdQcut.pty.spawn({
  command: 'python3 -c "print(42)"',
  cwd: '/Users/alice/project',
  cols: 120,
  rows: 30,
});

await window.wzrdQcut.pty.write(sessionId, 'ls -la\n');

await window.wzrdQcut.pty.resize(sessionId, 132, 40);

await window.wzrdQcut.pty.kill(sessionId);

await window.wzrdQcut.pty.killAll();

const unsubscribe = window.wzrdQcut.pty.onData(({ sessionId, data }) => {
  terminalElement.write(data);
});

const unsubscribe = window.wzrdQcut.pty.onExit(({ sessionId, exitCode }) => {
  console.log(`PTY ${sessionId} exited with code ${exitCode}`);
});

const rootPath = await window.wzrdQcut.projectFolder.getRoot('my-project-id');
// → "/Users/alice/Library/Application Support/WZRD Studio/qcut-projects/my-project-id"

interface DirectoryEntry {
  name: string;
  path: string;
  relativePath: string;
  type: 'video' | 'audio' | 'image' | 'unknown';
  size: number;
  modifiedAt: number;   // Unix ms
  isDirectory: boolean;
}

const entries = await window.wzrdQcut.projectFolder.list('my-project-id', 'media');

interface ScanOptions {
  recursive?: boolean;   // Default: false
  mediaOnly?: boolean;   // If true, skips files with unrecognised extensions
}

interface ScanResult {
  files: DirectoryEntry[];
  folders: string[];      // Relative paths of all discovered sub-directories
  totalSize: number;      // Bytes
  scanTime: number;       // Milliseconds taken
}

const result = await window.wzrdQcut.projectFolder.scan('my-project-id', '', {
  recursive: true,
  mediaOnly: true,
});

await window.wzrdQcut.projectFolder.ensureStructure('my-project-id');

interface Skill {
  id: string;            // Folder name
  name: string;
  description: string;
  dependencies?: string;
  folderName: string;
  mainFile: 'Skill.md';
  additionalFiles: string[];
  content: string;       // Full normalized Skill.md content
  createdAt: number;
  updatedAt: number;
}

const skills = await window.wzrdQcut.skills.list('my-project-id');

const skill = await window.wzrdQcut.skills.import('my-project-id', '/path/to/my-skill-folder');

await window.wzrdQcut.skills.delete('my-project-id', 'color-grading-skill');

const content = await window.wzrdQcut.skills.getContent('my-project-id', 'color-grading-skill', 'Skill.md');

const result = await window.wzrdQcut.skills.syncForClaude('my-project-id');
// → { synced: true, copied: 3, skipped: 1, removed: 0, warnings: [] }

const available = await window.wzrdQcut.skills.scanGlobal();
// → [{ path, name, description, bundled: false }, ...]

const info = await window.wzrdQcut.mcp.getInfo();

const unsubscribe = window.wzrdQcut.mcp.onAppHtml((payload) => {
  // Handle HTML payload from agent
});