import { app, BrowserWindow, clipboard, dialog, ipcMain, shell, } from 'electron'; import Store from 'electron-store'; import { appendFile, copyFile, mkdir, readdir, readFile, rm, unlink, writeFile, } from 'fs/promises'; import detectUsb from 'detect-usb'; import path from 'path'; import { eject } from 'eject-media'; import { format } from 'date-fns'; import { EventEmitter } from 'events'; import { MatchResult } from '@parry-gg/client'; import { createWriteStream } from 'fs'; import yauzl from 'yauzl-promise'; import { pipeline } from 'stream/promises'; import { ChallongeMatchItem, Context, CopySettings, EnforcePlayerFailure, EnforcerSetting, EnforceState, EnforceStatus, Id, Mode, Output, ParryggGame, Replay, ReportSettings, SelectedSetChain, Set, StartggGame, StartggSet, } from '../common/types'; import { getEvent, getPhase, getPhaseGroup, getTournament, callSet, startSet, reportSet, updateSet, getTournaments, getCurrentTournament, getSelectedSet, setSelectedSetId, resetSet, assignStream, assignStation, getPoolsByWave, getSelectedSetChain, } from './startgg'; import { getReplaysInDir, getReportedSubdirs, writeReplays } from './replay'; import { getChallongeTournament, getChallongeTournaments, getCurrentTournaments, getSelectedChallongeSet, getSelectedTournament, reportChallongeSet, setSelectedChallongeSetId, setSelectedTournament, startChallongeSet, } from './challonge'; import { getParryggTournament, getParryggTournaments, getParryggEvent, getParryggPhase, getParryggBracket, getSelectedParryggSet, getCurrentParryggTournament, reportParryggSet, setSelectedParryggSetId, setSelectedParryggTournament, startParryggSet, getAdminedParryggTournaments, getSelectedParryggSetChain, } from './parrygg'; import { appendEnforcerResult, connectToHost, deleteZip, disconnectFromHost, getCopyClients, getHost, getHostFormat, isBroadcasting, kickCopyClient, setCopyDir, setMainWindow, setOwnCopySettings, setOwnEnforcerSetting, setOwnFileNameFormat, setOwnFolderNameFormat, setOwnSmuggleCostumeIndex, startBroadcasting, startHostServer, startListening, stopBroadcasting, stopHostServer, stopListening, stopListeningAndSend, } from './host'; import { assertInteger, assertString } from '../common/asserts'; import { resolveHtmlPath } from './util'; import { assignOfflineModeSetStation, assignOfflineModeSetStream, callOfflineModeSet, connectToOfflineMode, deafenForOfflineMode, disconnectFromOfflineMode, getCurrentOfflineModeTournament, getOfflineModePoolsByWave, getOfflineModeStatus, getOfflineModeHosts, getSelectedOfflineModeSet, getSelectedOfflineModeSetChain, initOfflineMode, listenForOfflineMode, reportOfflineModeSet, resetOfflineModeSet, setOfflineModePassword, setSelectedOfflineModeSetId, startOfflineModeSet, deafenForOfflineModeAndSend, } from './offlinemode'; type ReplayDir = { dir: string; usbKey: string; }; let entrantsWindow: BrowserWindow | null = null; const protocolLoadFullPath = path.join(app.getPath('userData'), 'protocol'); const undoDstFullPath = path.join(app.getPath('userData'), 'undo'); export default function setupIPCs( mainWindow: BrowserWindow, enforcerWindow: BrowserWindow, eventEmitter: EventEmitter, ): void { const store = new Store<{ copySettings: CopySettings; hideCopyButton: boolean; offlineModePassword: string; }>(); initOfflineMode(mainWindow); let offlineModePassword = store.get('offlineModePassword', ''); setOfflineModePassword(offlineModePassword); ipcMain.removeHandler('getOfflineModePassword'); ipcMain.handle('getOfflineModePassword', () => offlineModePassword); ipcMain.removeHandler('setOfflineModePassword'); ipcMain.handle( 'setOfflineModePassword', (event, newOfflineModePassword: string) => { offlineModePassword = newOfflineModePassword; store.set('offlineModePassword', offlineModePassword); setOfflineModePassword(offlineModePassword); }, ); let replayDirs: ReplayDir[] = []; const knownUsbs = new Map(); // Helper to add a new replay directory and notify renderer function addReplayDir(dir: string, usbKey: string) { replayDirs.push({ dir, usbKey }); mainWindow.webContents.send('usbstorage', dir, Boolean(usbKey)); } // Helper to download a file from a URL to a given path async function downloadFile(url: string, dest: string): Promise { let response; try { response = await fetch(url, { signal: AbortSignal.timeout(15000), }); } catch (error) { if (error instanceof Error && error.name === 'AbortError') { throw new Error(`Timeout downloading '${url}'`); } throw error; } if (!response.ok) { throw new Error(`Failed to get '${url}' (${response.status})`); } if (!response.body) { throw new Error(`No response body for '${url}'`); } await writeFile(dest, Buffer.from(await response.arrayBuffer())); } let slpDownloadStatus: { status: 'idle' | 'downloading' | 'error' | 'success'; slpUrls?: string[]; progress?: number; currentFile?: string; failedFiles?: string[]; } = { status: 'idle' }; async function handleProtocolLoadSlpUrls(slpUrls: string[]) { await mkdir(protocolLoadFullPath, { recursive: true }); const failedFiles: string[] = []; const total = slpUrls.length; let completed = 0; await Promise.all( slpUrls.map(async (url) => { const fileName = path.basename(new URL(url).pathname); const dest = path.join(protocolLoadFullPath, fileName); try { await downloadFile(url, dest); } catch (err) { // Delete partial files try { await unlink(dest); } catch (unlinkErr) { // ignore } failedFiles.push(url); } finally { completed += 1; slpDownloadStatus = { status: 'downloading', slpUrls, progress: Math.round((completed / total) * 100), currentFile: fileName, }; if (mainWindow) { mainWindow.webContents.send( 'slp-download-status', slpDownloadStatus, ); } } }), ); // Emit 100% progress after last file slpDownloadStatus = { status: 'downloading', slpUrls, progress: 100, currentFile: '', }; if (mainWindow) { mainWindow.webContents.send('slp-download-status', slpDownloadStatus); } if (failedFiles.length > 0) { slpDownloadStatus = { status: 'error', failedFiles }; if (mainWindow) mainWindow.webContents.send('slp-download-status', slpDownloadStatus); } else { slpDownloadStatus = { status: 'success' }; if (mainWindow) mainWindow.webContents.send('slp-download-status', slpDownloadStatus); addReplayDir(protocolLoadFullPath, ''); } } eventEmitter.on('protocol-load-slp-urls', (slpUrls: string[]) => { handleProtocolLoadSlpUrls(slpUrls); }); const onInsert = (e: any) => { if (knownUsbs.has(e.data.key)) { return; } if (e.data.isAccessible) { knownUsbs.set(e.data.key, true); const dir = process.platform === 'win32' ? `${e.data.key}Slippi` : path.join(e.data.key, 'Slippi'); addReplayDir(dir, e.data.key); } }; const onEject = (e: any) => { if (!knownUsbs.has(e.data.key)) { return; } knownUsbs.delete(e.data.key); replayDirs = replayDirs.filter((dir) => !dir.dir.startsWith(e.data.key)); const newDir = replayDirs.length > 0 ? replayDirs[replayDirs.length - 1] : null; mainWindow.webContents.send( 'usbstorage', newDir ? newDir.dir : '', Boolean(newDir?.usbKey), ); }; detectUsb.removeAllListeners('insert'); detectUsb.on('insert', onInsert); detectUsb.removeAllListeners('eject'); detectUsb.on('eject', onEject); detectUsb.startListening(); let mode = store.has('mode') ? (store.get('mode') as Mode) : Mode.STARTGG; if (mode === Mode.OFFLINE_MODE) { listenForOfflineMode(); } ipcMain.removeHandler('getMode'); ipcMain.handle('getMode', () => mode); ipcMain.removeHandler('setMode'); ipcMain.handle('setMode', (event, newMode: Mode) => { if (mode !== newMode && mode === Mode.OFFLINE_MODE) { disconnectFromOfflineMode(); deafenForOfflineModeAndSend(); } store.set('mode', newMode); mode = newMode; }); let selectedEventId: Id; let selectedPhaseId: Id; let selectedPhaseGroupId: Id; if (mode === Mode.PARRYGG) { selectedEventId = ''; selectedPhaseId = ''; selectedPhaseGroupId = ''; } else { selectedEventId = 0; selectedPhaseId = 0; selectedPhaseGroupId = 0; } let undoSrcFullPath = ''; ipcMain.removeHandler('getReplaysDir'); ipcMain.handle('getReplaysDir', () => { if (undoSrcFullPath) { return undoDstFullPath; } return replayDirs.length > 0 ? replayDirs[replayDirs.length - 1].dir : ''; }); let chosenReplaysDir = ''; ipcMain.removeHandler('chooseReplaysDir'); ipcMain.handle('chooseReplaysDir', async () => { const openDialogRes = await dialog.showOpenDialog({ properties: ['openDirectory', 'showHiddenFiles', 'createDirectory'], }); if (openDialogRes.canceled) { return replayDirs.length > 0 ? replayDirs[replayDirs.length - 1].dir : ''; } if (chosenReplaysDir) { const spliceI = replayDirs.findIndex( ({ dir }) => dir === chosenReplaysDir, ); if (spliceI >= 0) { replayDirs.splice(spliceI, 1); } } [chosenReplaysDir] = openDialogRes.filePaths; replayDirs.push({ dir: chosenReplaysDir, usbKey: '' }); return chosenReplaysDir; }); const maybeEject = (currentDir: ReplayDir) => { if (currentDir.usbKey) { return new Promise((resolve) => { eject(currentDir.usbKey, () => { // best effort resolve(true); }); }); } return Promise.resolve(false); }; let trashDir = store.get('trashDir', '') as string; ipcMain.removeHandler('getTrashDir'); ipcMain.handle('getTrashDir', () => trashDir); ipcMain.removeHandler('chooseTrashDir'); ipcMain.handle('chooseTrashDir', async () => { const openDialogRes = await dialog.showOpenDialog({ properties: ['openDirectory', 'showHiddenFiles', 'createDirectory'], }); if (openDialogRes.canceled) { return trashDir; } [trashDir] = openDialogRes.filePaths; store.set('trashDir', trashDir); return trashDir; }); ipcMain.removeHandler('clearTrashDir'); ipcMain.handle('clearTrashDir', () => { store.set('trashDir', ''); trashDir = ''; }); let copyDir = ''; ipcMain.removeHandler('deleteReplaysDir'); ipcMain.handle('deleteReplaysDir', async (event, usedFilenames: string[]) => { if (replayDirs.length === 0 && !undoSrcFullPath) { return Promise.resolve(false); } const currentDir = undoSrcFullPath ? undoDstFullPath : replayDirs[replayDirs.length - 1].dir; if (currentDir && copyDir && currentDir === copyDir) { return Promise.resolve(false); } const slpFilenames = (await readdir(currentDir, { withFileTypes: true })) .filter((dirent) => dirent.isFile() && dirent.name.endsWith('.slp')) .map((dirent) => dirent.name); if (trashDir) { const trashSubdir = format(new Date(), 'yyyy-MM-dd HHmmss'); const fullPath = path.join(trashDir, trashSubdir); await mkdir(fullPath, { recursive: true }); const usedFilenamesMap = new Map( usedFilenames.map((filename) => [filename, true]), ); await Promise.all( slpFilenames.map(async (filename) => { const srcPath = path.join(currentDir, filename); const dstDir = usedFilenamesMap.has(fullPath) ? path.join(fullPath, 'used') : path.join(fullPath, 'unused'); await mkdir(dstDir, { recursive: true }); const dstPath = path.join(dstDir, filename); return copyFile(srcPath, dstPath); }), ); } await Promise.all( slpFilenames.map(async (filename) => { const unlinkPath = path.join(currentDir, filename); return unlink(unlinkPath); }), ); return undoSrcFullPath ? Promise.resolve(false) : maybeEject(replayDirs[replayDirs.length - 1]); }); ipcMain.removeHandler('deleteSelectedReplays'); ipcMain.handle( 'deleteSelectedReplays', async (event, replayPaths: string[], used: boolean) => { if (trashDir) { const trashSubdir = format(new Date(), 'yyyy-MM-dd HHmmss'); const fullPath = path.join( trashDir, trashSubdir, used ? 'used' : 'unused', ); await mkdir(fullPath, { recursive: true }); await Promise.all( replayPaths.map(async (replayPath) => { const dstPath = path.join(fullPath, path.basename(replayPath)); return copyFile(replayPath, dstPath); }), ); } await Promise.all(replayPaths.map(unlink)); }, ); ipcMain.removeHandler('maybeEject'); ipcMain.handle('maybeEject', () => maybeEject(replayDirs[replayDirs.length - 1]), ); let replayLoadCount = 0; let enforcerSetting = store.get('enforcerSetting', EnforcerSetting.NONE); setOwnEnforcerSetting(enforcerSetting); ipcMain.removeHandler('getReplaysInDir'); ipcMain.handle('getReplaysInDir', async () => { if (replayDirs.length === 0 && !undoSrcFullPath) { throw new Error(); } const replayDir = undoSrcFullPath ? undoDstFullPath : replayDirs[replayDirs.length - 1].dir; const retReplays = await getReplaysInDir(replayDir); replayLoadCount += 1; const currentReplayLoadCount = replayLoadCount; if ( (getHostFormat().enforcerSetting ?? enforcerSetting) !== EnforcerSetting.NONE ) { const pendingState: EnforceState = { status: EnforceStatus.PENDING, fileNameToPlayerFailures: new Map(), }; mainWindow.webContents.send( 'enforceState', pendingState, currentReplayLoadCount, ); enforcerWindow.webContents.send( 'enforcer', await Promise.all( retReplays.replays .filter((replay) => replay.lastFrame > -124) .map(async (replay) => { const buffer = await readFile(replay.filePath); return { fileName: replay.fileName, array: new Uint8Array( buffer.buffer, buffer.byteOffset, buffer.byteLength, ), }; }), ), currentReplayLoadCount, ); } return { ...retReplays, replayLoadCount: currentReplayLoadCount }; }); ipcMain.removeHandler('writeReplays'); ipcMain.handle( 'writeReplays', async ( event, fileNames: string[], output: Output, replays: Replay[], startTimes: string[], subdir: string, writeDisplayNames: boolean, context: Context | undefined, ) => { const host = getHost(); if (!host.address && !copyDir) { throw new Error('copy dir not set'); } return writeReplays( copyDir, host, fileNames, output, replays, startTimes, subdir, writeDisplayNames, context, ); }, ); ipcMain.removeHandler('appendEnforcerResult'); ipcMain.handle('appendEnforcerResult', async (event, str: string) => { const host = getHost(); if (!host.address && !copyDir) { throw new Error('must set copy dir'); } const promises = []; if (host.address) { promises.push(appendEnforcerResult(str)); } if (copyDir) { promises.push(appendFile(path.join(copyDir, 'enforcer.csv'), str)); } const rejections = (await Promise.allSettled(promises)).filter( (result) => result.status === 'rejected', ) as PromiseRejectedResult[]; if (rejections.length > 0) { throw new Error( rejections.map((rejection) => rejection.reason).join(', '), ); } }); ipcMain.removeHandler('getReportedSubdirs'); ipcMain.handle('getReportedSubdirs', () => copyDir ? getReportedSubdirs(copyDir) : [], ); ipcMain.removeHandler('getUndoSubdir'); ipcMain.handle('getUndoSubdir', () => path.basename(undoSrcFullPath)); ipcMain.removeHandler('setUndoSubdir'); ipcMain.handle('setUndoSubdir', async (event, newUndoSubdir: string) => { if (newUndoSubdir === '') { await rm(undoDstFullPath, { force: true, recursive: true }); undoSrcFullPath = ''; return replayDirs.length > 0 ? replayDirs[replayDirs.length - 1].dir : ''; } await mkdir(undoDstFullPath, { recursive: true }); const newUndoSrcFullPath = path.join(copyDir, newUndoSubdir); if (newUndoSrcFullPath.endsWith('.zip')) { try { const zip = await yauzl.open(newUndoSrcFullPath); try { // eslint-disable-next-line no-restricted-syntax for await (const entry of zip) { if (entry.filename.endsWith('.slp')) { const readStream = await entry.openReadStream(); const writeStream = createWriteStream( path.join(undoDstFullPath, entry.filename), ); await pipeline(readStream, writeStream); } } } finally { zip.close(); } } catch (e: any) { await rm(undoDstFullPath, { force: true, recursive: true }); throw e; } } else { const undoSlpNames = (await readdir(newUndoSrcFullPath)).filter((name) => name.endsWith('.slp'), ); try { await Promise.all( undoSlpNames.map(async (undoSlpName) => { const srcSlpFullPath = path.join(newUndoSrcFullPath, undoSlpName); const dstSlpFullPath = path.join(undoDstFullPath, undoSlpName); return copyFile(srcSlpFullPath, dstSlpFullPath); }), ); } catch (e: any) { await rm(undoDstFullPath, { force: true, recursive: true }); throw e; } } undoSrcFullPath = newUndoSrcFullPath; return undoDstFullPath; }); // host delete ipcMain.removeHandler('deleteUndoSrcDst'); ipcMain.handle('deleteUndoSrcDst', async () => { if (!undoSrcFullPath) { throw new Error('no undo subdir'); } if (undoSrcFullPath.endsWith('.zip') && getHost().address) { try { await deleteZip(path.basename(undoSrcFullPath, '.zip')); } catch { // just catch } } await rm(undoDstFullPath, { force: true, recursive: true }); await rm(undoSrcFullPath, { force: true, recursive: true }); undoSrcFullPath = ''; return replayDirs.length > 0 ? replayDirs[replayDirs.length - 1].dir : ''; }); ipcMain.removeHandler('getCopyDir'); ipcMain.handle('getCopyDir', () => copyDir); ipcMain.removeHandler('chooseCopyDir'); ipcMain.handle('chooseCopyDir', async () => { const openDialogRes = await dialog.showOpenDialog({ properties: ['openDirectory', 'showHiddenFiles', 'createDirectory'], }); if (openDialogRes.canceled) { return ''; } [copyDir] = openDialogRes.filePaths; setCopyDir(copyDir); return copyDir; }); setMainWindow(mainWindow); ipcMain.removeHandler('getCopyHost'); ipcMain.handle('getCopyHost', getHost); ipcMain.removeHandler('getCopyHostFormat'); ipcMain.handle('getCopyHostFormat', getHostFormat); ipcMain.removeHandler('startListeningForHosts'); ipcMain.handle('startListeningForHosts', startListening); ipcMain.removeHandler('stopListeningForHosts'); ipcMain.handle('stopListeningForHosts', stopListeningAndSend); ipcMain.removeHandler('connectToHost'); ipcMain.handle('connectToHost', (event, address: string) => connectToHost(address), ); ipcMain.removeHandler('disconnectFromHost'); ipcMain.handle('disconnectFromHost', disconnectFromHost); ipcMain.removeHandler('getCopyClients'); ipcMain.handle('getCopyClients', getCopyClients); ipcMain.removeHandler('kickCopyClient'); ipcMain.handle('kickCopyClient', (event, address: string) => kickCopyClient(address), ); ipcMain.removeHandler('startHostServer'); ipcMain.handle('startHostServer', startHostServer); ipcMain.removeHandler('stopHostServer'); ipcMain.handle('stopHostServer', stopHostServer); ipcMain.removeHandler('startBroadcastingHost'); ipcMain.handle('startBroadcastingHost', startBroadcasting); ipcMain.removeHandler('stopBroadcastingHost'); ipcMain.handle('stopBroadcastingHost', stopBroadcasting); let sggApiKey = store.has('sggApiKey') ? (store.get('sggApiKey') as string) : ''; ipcMain.removeHandler('getStartggKey'); ipcMain.handle('getStartggKey', () => sggApiKey); ipcMain.removeHandler('setStartggKey'); ipcMain.handle('setStartggKey', (event, newSggApiKey: string) => { store.set('sggApiKey', newSggApiKey); sggApiKey = newSggApiKey; }); ipcMain.removeHandler('getCurrentTournament'); ipcMain.handle('getCurrentTournament', getCurrentTournament); ipcMain.removeHandler('getSelectedSetChain'); ipcMain.handle('getSelectedSetChain', (): SelectedSetChain => { if (mode === Mode.STARTGG) { return getSelectedSetChain( assertInteger(selectedEventId), assertInteger(selectedPhaseId), assertInteger(selectedPhaseGroupId), ); } if (mode === Mode.PARRYGG) { return getSelectedParryggSetChain( assertString(selectedEventId), assertString(selectedPhaseId), assertString(selectedPhaseGroupId), ); } if (mode === Mode.OFFLINE_MODE) { return getSelectedOfflineModeSetChain( assertInteger(selectedEventId), assertInteger(selectedPhaseId), assertInteger(selectedPhaseGroupId), ); } return {}; }); ipcMain.removeHandler('setSelectedSetChain'); ipcMain.handle( 'setSelectedSetChain', (event, eventId: Id, phaseId: Id, phaseGroupId: Id) => { selectedEventId = eventId; selectedPhaseId = phaseId; selectedPhaseGroupId = phaseGroupId; }, ); ipcMain.removeHandler('getStartggTournament'); ipcMain.handle( 'getStartggTournament', async (event, slugOrShort: string, recursive: boolean) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } await getTournament(sggApiKey, slugOrShort, recursive); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }, ); ipcMain.removeHandler('getEvent'); ipcMain.handle('getEvent', async (ev, id: number) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } await getEvent(sggApiKey, id, false); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }); ipcMain.removeHandler('getPhase'); ipcMain.handle('getPhase', async (event, id: number) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } await getPhase(sggApiKey, id, false); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }); ipcMain.removeHandler('getPhaseGroup'); ipcMain.handle('getPhaseGroup', async (event, id: number) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } await getPhaseGroup(sggApiKey, id); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }); const getRealSetId = async (key: string, originalSet: Set) => { const updatedPhaseGroup = await getPhaseGroup( key, assertInteger(selectedPhaseGroupId), ); const candidateRealSets = updatedPhaseGroup.sets.pendingSets.filter( (realSet) => realSet.entrant1Id === originalSet.entrant1Id && realSet.entrant2Id === originalSet.entrant2Id && realSet.round === originalSet.round, ); if (candidateRealSets.length === 1) { return assertInteger(candidateRealSets[0].id); } return null; }; ipcMain.removeHandler('assignStream'); ipcMain.handle( 'assignStream', async (event, originalSet: Set, streamId: number) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } try { await assignStream(sggApiKey, originalSet.id, streamId); } catch (e: unknown) { if ( e instanceof Error && e.message.startsWith('An unknown error has occurred') ) { const realSetId = await getRealSetId(sggApiKey, originalSet); if (realSetId) { await assignStream(sggApiKey, realSetId, streamId); } else { throw e; } } else { throw e; } } await getPhaseGroup(sggApiKey, assertInteger(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }, ); ipcMain.removeHandler('assignStation'); ipcMain.handle( 'assignStation', async (event, originalSet: Set, stationId: number) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } try { await assignStation(sggApiKey, originalSet.id, stationId); } catch (e: unknown) { if ( e instanceof Error && e.message.startsWith('An unknown error has occurred') ) { const realSetId = await getRealSetId(sggApiKey, originalSet); if (realSetId) { await assignStation(sggApiKey, realSetId, stationId); } else { throw e; } } else { throw e; } } await getPhaseGroup(sggApiKey, assertInteger(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }, ); ipcMain.removeHandler('resetSet'); ipcMain.handle('resetSet', async (event, setId: number) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } await resetSet(sggApiKey, setId); await getPhaseGroup(sggApiKey, assertInteger(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }); ipcMain.removeHandler('callSet'); ipcMain.handle('callSet', async (event, originalSet: Set) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } try { await callSet(sggApiKey, originalSet.id); } catch (e: unknown) { if ( e instanceof Error && e.message.startsWith('Set not found for id: preview') ) { const realSetId = await getRealSetId(sggApiKey, originalSet); if (realSetId) { await callSet(sggApiKey, realSetId); } else { throw e; } } else { throw e; } } await getPhaseGroup(sggApiKey, assertInteger(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }); ipcMain.removeHandler('startSet'); ipcMain.handle('startSet', async (event, originalSet: Set) => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } try { await startSet(sggApiKey, originalSet.id); } catch (e: unknown) { if ( e instanceof Error && e.message.startsWith('Set not found for id: preview') ) { const realSetId = await getRealSetId(sggApiKey, originalSet); if (realSetId) { await startSet(sggApiKey, realSetId); } else { throw e; } } else { throw e; } } await getPhaseGroup(sggApiKey, assertInteger(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); }); ipcMain.removeHandler('reportSet'); ipcMain.handle( 'reportSet', async ( event, set: StartggSet, originalSet: Set, ): Promise => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } let updatedSet: Set | undefined; try { updatedSet = await reportSet( sggApiKey, set, assertInteger(selectedPhaseGroupId), ); } catch (e: unknown) { if (e instanceof Error) { if (e.message === 'Cannot report completed set via API.') { if (set.gameData.length > 0) { updatedSet = await updateSet(sggApiKey, set); } } else if (e.message.startsWith('Set not found for id: preview')) { const realSetId = await getRealSetId(sggApiKey, originalSet); if (realSetId) { set.setId = realSetId; try { updatedSet = await reportSet( sggApiKey, set, assertInteger(selectedPhaseGroupId), ); } catch (e2: unknown) { if ( e2 instanceof Error && e2.message === 'Cannot report completed set via API.' ) { if (set.gameData.length > 0) { updatedSet = await updateSet(sggApiKey, set); } } else { throw e2; } } } else { throw e; } } else { throw e; } } else { throw e; } } const updatedPhaseGroup = await getPhaseGroup( sggApiKey, assertInteger(selectedPhaseGroupId), ); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); if (!updatedSet) { updatedSet = updatedPhaseGroup.sets.completedSets.find( (completedSet) => completedSet.id === set.setId, ); } return updatedSet; }, ); ipcMain.removeHandler('updateSet'); ipcMain.handle( 'updateSet', async (event, set: StartggSet): Promise => { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } const updatedSet = await updateSet(sggApiKey, set); await getPhaseGroup(sggApiKey, assertInteger(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedSet(), startggTournament: getCurrentTournament(), }); return updatedSet; }, ); ipcMain.removeHandler('getPoolsByWave'); ipcMain.handle('getPoolsByWave', async () => { if (mode === Mode.STARTGG) { if (!sggApiKey) { throw new Error('Please set start.gg API key'); } return getPoolsByWave(sggApiKey); } if (mode === Mode.OFFLINE_MODE) { return getOfflineModePoolsByWave(); } return []; }); let challongeApiKey = store.has('challongeApiKey') ? (store.get('challongeApiKey') as string) : ''; ipcMain.removeHandler('getChallongeKey'); ipcMain.handle('getChallongeKey', () => challongeApiKey); ipcMain.removeHandler('setChallongeKey'); ipcMain.handle('setChallongeKey', (event, newChallongeKey: string) => { store.set('challongeApiKey', newChallongeKey); challongeApiKey = newChallongeKey; }); let parryggApiKey = store.has('parryggApiKey') ? (store.get('parryggApiKey') as string) : ''; ipcMain.removeHandler('getParryggKey'); ipcMain.handle('getParryggKey', () => parryggApiKey); ipcMain.removeHandler('setParryggKey'); ipcMain.handle('setParryggKey', (event, newParryggKey: string) => { store.set('parryggApiKey', newParryggKey); parryggApiKey = newParryggKey; }); ipcMain.removeHandler('getCurrentChallongeTournaments'); ipcMain.handle('getCurrentChallongeTournaments', getCurrentTournaments); ipcMain.removeHandler('getSelectedChallongeTournament'); ipcMain.handle('getSelectedChallongeTournament', getSelectedTournament); ipcMain.removeHandler('setSelectedChallongeTournament'); ipcMain.handle('setSelectedChallongeTournament', (event, slug: string) => { setSelectedTournament(slug); }); ipcMain.removeHandler('getChallongeTournament'); ipcMain.handle('getChallongeTournament', async (event, slug: string) => { if (!challongeApiKey) { throw new Error('Please set Challonge API key.'); } await getChallongeTournament(challongeApiKey, slug); mainWindow.webContents.send('tournament', { selectedSet: getSelectedChallongeSet(), challongeTournaments: getCurrentTournaments(), }); }); ipcMain.removeHandler('startChallongeSet'); ipcMain.handle( 'startChallongeSet', async (event, slug: string, id: string) => { if (!challongeApiKey) { throw new Error('Please set Challonge API key.'); } await startChallongeSet(slug, id, challongeApiKey); await getChallongeTournament(challongeApiKey, slug); mainWindow.webContents.send('tournament', { selectedSet: getSelectedChallongeSet(), challongeTournaments: getCurrentTournaments(), }); }, ); ipcMain.removeHandler('reportChallongeSet'); ipcMain.handle( 'reportChallongeSet', async (event, id: string, items: ChallongeMatchItem[]) => { if (!challongeApiKey) { throw new Error('Please set Challonge API key.'); } const slug = getSelectedTournament()?.slug; if (!slug) { throw new Error('unreachable, no selected challonge tournament'); } const updatedSet = await reportChallongeSet( slug, id, items, challongeApiKey, ); await getChallongeTournament(challongeApiKey, slug); mainWindow.webContents.send('tournament', { selectedSet: getSelectedChallongeSet(), challongeTournaments: getCurrentTournaments(), }); return updatedSet; }, ); ipcMain.removeHandler('getAdminedParryggTournaments'); ipcMain.handle('getAdminedParryggTournaments', getAdminedParryggTournaments); ipcMain.removeHandler('getCurrentParryggTournament'); ipcMain.handle('getCurrentParryggTournament', getCurrentParryggTournament); ipcMain.removeHandler('setSelectedParryggTournament'); ipcMain.handle('setSelectedParryggTournament', (event, slug: string) => { setSelectedParryggTournament(slug); }); ipcMain.removeHandler('getSelectedParryggSet'); ipcMain.handle('getSelectedParryggSet', getSelectedParryggSet); ipcMain.removeHandler('setSelectedParryggSetId'); ipcMain.handle('setSelectedParryggSetId', (event, setId: string) => { setSelectedParryggSetId(setId); }); ipcMain.removeHandler('getParryggTournament'); ipcMain.handle( 'getParryggTournament', async (event, slug: string, recursive?: boolean) => { if (!parryggApiKey) { throw new Error('Please set parry.gg API key.'); } await getParryggTournament(parryggApiKey, slug, recursive); mainWindow.webContents.send('tournament', { selectedSet: getSelectedParryggSet(), parryggTournament: getCurrentParryggTournament(), }); }, ); ipcMain.removeHandler('getParryggEvent'); ipcMain.handle('getParryggEvent', async (event, eventId: string) => { if (!parryggApiKey) { throw new Error('Please set parry.gg API key.'); } await getParryggEvent(parryggApiKey, eventId); mainWindow.webContents.send('tournament', { selectedSet: getSelectedParryggSet(), parryggTournament: getCurrentParryggTournament(), }); }); ipcMain.removeHandler('getParryggPhase'); ipcMain.handle('getParryggPhase', async (event, phaseId: string) => { if (!parryggApiKey) { throw new Error('Please set parry.gg API key.'); } await getParryggPhase(parryggApiKey, phaseId); mainWindow.webContents.send('tournament', { selectedSet: getSelectedParryggSet(), parryggTournament: getCurrentParryggTournament(), }); }); ipcMain.removeHandler('getParryggBracket'); ipcMain.handle('getParryggBracket', async (event, bracketId: string) => { if (!parryggApiKey) { throw new Error('Please set parry.gg API key.'); } await getParryggBracket(parryggApiKey, bracketId); mainWindow.webContents.send('tournament', { selectedSet: getSelectedParryggSet(), parryggTournament: getCurrentParryggTournament(), }); }); ipcMain.removeHandler('startParryggSet'); ipcMain.handle('startParryggSet', async (event, setId: string) => { if (!parryggApiKey) { throw new Error('Please set parry.gg API key.'); } await startParryggSet(parryggApiKey, setId); await getParryggBracket(parryggApiKey, assertString(selectedPhaseGroupId)); mainWindow.webContents.send('tournament', { selectedSet: getSelectedParryggSet(), parryggTournament: getCurrentParryggTournament(), }); }); ipcMain.removeHandler('reportParryggSet'); ipcMain.handle( 'reportParryggSet', async ( event, setId: string, result: MatchResult.AsObject, games?: ParryggGame[], ) => { if (!parryggApiKey) { throw new Error('Please set parry.gg API key.'); } const updatedSet = await reportParryggSet( parryggApiKey, setId, result, games, ); await getParryggBracket( parryggApiKey, assertString(selectedPhaseGroupId), ); mainWindow.webContents.send('tournament', { selectedSet: getSelectedParryggSet(), parryggTournament: getCurrentParryggTournament(), }); return updatedSet; }, ); ipcMain.removeHandler('getOfflineModeStatus'); ipcMain.handle('getOfflineModeStatus', getOfflineModeStatus); ipcMain.removeHandler('getOfflineModeHosts'); ipcMain.handle('getOfflineModeHosts', getOfflineModeHosts); ipcMain.removeHandler('getCurrentOfflineModeTournament'); ipcMain.handle( 'getCurrentOfflineModeTournament', getCurrentOfflineModeTournament, ); ipcMain.removeHandler('listenForOfflineMode'); ipcMain.handle('listenForOfflineMode', listenForOfflineMode); ipcMain.removeHandler('connectToOfflineMode'); ipcMain.handle('connectToOfflineMode', (event, addressOrHost: string) => connectToOfflineMode(addressOrHost), ); ipcMain.removeHandler('resetOfflineModeSet'); ipcMain.handle('resetOfflineModeSet', (event, id: number) => resetOfflineModeSet(id), ); ipcMain.removeHandler('callOfflineModeSet'); ipcMain.handle('callOfflineModeSet', (event, id: number) => callOfflineModeSet(id), ); ipcMain.removeHandler('startOfflineModeSet'); ipcMain.handle('startOfflineModeSet', (event, id: number) => startOfflineModeSet(id), ); ipcMain.removeHandler('assignOfflineModeSetStation'); ipcMain.handle( 'assignOfflineModeSetStation', (event, id: number, stationId: number) => assignOfflineModeSetStation(id, stationId), ); ipcMain.removeHandler('assignOfflineModeSetStream'); ipcMain.handle( 'assignOfflineModeSetStream', (event, id: number, streamId: number) => assignOfflineModeSetStream(id, streamId), ); ipcMain.removeHandler('reportOfflineModeSet'); ipcMain.handle( 'reportOfflineModeSet', ( event, id: number, winnerId: number, isDQ: boolean, gameData: StartggGame[], ) => reportOfflineModeSet(id, winnerId, isDQ, gameData), ); ipcMain.removeHandler('getTournaments'); ipcMain.handle('getTournaments', async () => { if (mode === Mode.STARTGG) { return sggApiKey ? getTournaments(sggApiKey) : []; } if (mode === Mode.CHALLONGE) { return challongeApiKey ? getChallongeTournaments(challongeApiKey) : []; } if (mode === Mode.PARRYGG) { return parryggApiKey ? getParryggTournaments(parryggApiKey) : []; } return []; }); ipcMain.removeHandler('getSelectedSet'); ipcMain.handle('getSelectedSet', () => { if (mode === Mode.STARTGG) { return getSelectedSet(); } if (mode === Mode.CHALLONGE) { return getSelectedChallongeSet(); } if (mode === Mode.PARRYGG) { return getSelectedParryggSet(); } if (mode === Mode.OFFLINE_MODE) { return getSelectedOfflineModeSet(); } return undefined; }); ipcMain.removeHandler('setSelectedSetId'); ipcMain.handle('setSelectedSetId', (event, selectedSetId: Id) => { if (!selectedSetId) { return; } if (mode === Mode.STARTGG) { setSelectedSetId(selectedSetId); } else if (mode === Mode.CHALLONGE) { setSelectedChallongeSetId(assertString(selectedSetId)); } else if (mode === Mode.PARRYGG) { setSelectedParryggSetId(assertString(selectedSetId)); } else if (mode === Mode.OFFLINE_MODE) { setSelectedOfflineModeSetId(assertInteger(selectedSetId)); } }); let manualNames = store.has('manualNames') ? (store.get('manualNames') as string[]) : []; ipcMain.removeHandler('getManualNames'); ipcMain.handle('getManualNames', () => manualNames); ipcMain.removeHandler('setManualNames'); ipcMain.handle('setManualNames', (event, newManualNames: string[]) => { store.set('manualNames', newManualNames); manualNames = newManualNames; }); ipcMain.removeHandler('getUseLAN'); ipcMain.handle('getUseLAN', () => { if (store.has('useLAN')) { return store.get('useLAN') as boolean; } store.set('useLAN', false); return false; }); ipcMain.removeHandler('setUseLAN'); ipcMain.handle('setUseLAN', (event, newUseLAN: boolean) => { store.set('useLAN', newUseLAN); if (!newUseLAN) { stopListeningAndSend(); stopBroadcasting(); stopHostServer(); } }); ipcMain.removeHandler('getEnforcerSetting'); ipcMain.handle('getEnforcerSetting', () => enforcerSetting); ipcMain.removeHandler('setEnforcerSetting'); ipcMain.handle( 'setEnforcerSetting', (event, newEnforcerSetting: EnforcerSetting) => { store.set('enforcerSetting', newEnforcerSetting); enforcerSetting = newEnforcerSetting; setOwnEnforcerSetting(enforcerSetting); }, ); // {date} // {time} // {roundShort} // {roundLong} // {playersOnly} // {playersChars} // {singlesChars} // {stage} // {ordinal} const INITIAL_FILE_NAME_FORMAT = ' - {playersChars} - {stage}'; let fileNameFormat = store.get( 'fileNameFormat', INITIAL_FILE_NAME_FORMAT, ) as string; if (fileNameFormat.startsWith('{ordinal}')) { fileNameFormat = fileNameFormat.slice(9); store.set('fileNameFormat', fileNameFormat); } setOwnFileNameFormat(fileNameFormat); ipcMain.removeHandler('getFileNameFormat'); ipcMain.handle('getFileNameFormat', () => fileNameFormat); ipcMain.removeHandler('setFileNameFormat'); ipcMain.handle('setFileNameFormat', (event, newFileNameFormat: string) => { if (!newFileNameFormat) { throw new Error('File name format cannot be empty.'); } if (fileNameFormat !== newFileNameFormat) { store.set('fileNameFormat', newFileNameFormat); fileNameFormat = newFileNameFormat; setOwnFileNameFormat(fileNameFormat); } }); ipcMain.removeHandler('resetFileNameFormat'); ipcMain.handle('resetFileNameFormat', () => { if (fileNameFormat !== INITIAL_FILE_NAME_FORMAT) { store.set('fileNameFormat', INITIAL_FILE_NAME_FORMAT); fileNameFormat = INITIAL_FILE_NAME_FORMAT; setOwnFileNameFormat(fileNameFormat); } return fileNameFormat; }); // {date} // {time} // {roundShort} // {roundLong} // {playersOnly} // {playersChars} // {singlesChars} // {games} // {phaseGroup} // {phase} // {event} // {phaseOrEvent} const INITIAL_FOLDER_NAME_FORMAT = '{phaseOrEvent} {roundShort} - {playersChars}'; let folderNameFormat = store.get( 'folderNameFormat', INITIAL_FOLDER_NAME_FORMAT, ) as string; setOwnFolderNameFormat(folderNameFormat); ipcMain.removeHandler('getFolderNameFormat'); ipcMain.handle('getFolderNameFormat', () => folderNameFormat); ipcMain.removeHandler('setFolderNameFormat'); ipcMain.handle( 'setFolderNameFormat', (event, newFolderNameFormat: string) => { if (!newFolderNameFormat) { throw new Error('Folder name format cannot be empty.'); } if (folderNameFormat !== newFolderNameFormat) { store.set('folderNameFormat', newFolderNameFormat); folderNameFormat = newFolderNameFormat; setOwnFolderNameFormat(folderNameFormat); } }, ); ipcMain.removeHandler('resetFolderNameFormat'); ipcMain.handle('resetFolderNameFormat', () => { if (folderNameFormat !== INITIAL_FOLDER_NAME_FORMAT) { store.set('folderNameFormat', INITIAL_FOLDER_NAME_FORMAT); folderNameFormat = INITIAL_FOLDER_NAME_FORMAT; setOwnFolderNameFormat(folderNameFormat); } return folderNameFormat; }); ipcMain.removeHandler('getHideCopyButton'); ipcMain.handle('getHideCopyButton', () => store.get('hideCopyButton', true)); ipcMain.removeHandler('setHideCopyButton'); ipcMain.handle('setHideCopyButton', (event, hideCopyButton: boolean) => { store.set('hideCopyButton', hideCopyButton); }); let copySettings = store.get('copySettings', { output: Output.ZIP, writeContext: true, writeDisplayNames: true, writeFileNames: true, writeStartTimes: true, }); setOwnCopySettings(copySettings); ipcMain.removeHandler('getCopySettings'); ipcMain.handle('getCopySettings', () => copySettings); ipcMain.removeHandler('setCopySettings'); ipcMain.handle('setCopySettings', (event, newCopySettings: CopySettings) => { store.set('copySettings', newCopySettings); copySettings = newCopySettings; setOwnCopySettings(copySettings); }); ipcMain.removeHandler('getReportSettings'); ipcMain.handle('getReportSettings', () => { if (store.has('reportSettings')) { return store.get('reportSettings') as ReportSettings; } const newReportSettings: ReportSettings = { alsoCopy: true, alsoDelete: true, }; store.set('reportSettings', newReportSettings); return newReportSettings; }); ipcMain.removeHandler('setReportSettings'); ipcMain.handle( 'setReportSettings', (event, newReportSettings: ReportSettings) => { store.set('reportSettings', newReportSettings); }, ); let vlerkMode = store.has('vlerkMode') ? (store.get('vlerkMode') as boolean) : false; ipcMain.removeHandler('getVlerkMode'); ipcMain.handle('getVlerkMode', () => vlerkMode); ipcMain.removeHandler('setVlerkMode'); ipcMain.handle('setVlerkMode', (event, newVlerkMode: boolean) => { store.set('vlerkMode', newVlerkMode); vlerkMode = newVlerkMode; }); let guidedMode = store.has('guidedMode') ? (store.get('guidedMode') as boolean) : true; ipcMain.removeHandler('getGuidedMode'); ipcMain.handle('getGuidedMode', () => guidedMode); ipcMain.removeHandler('setGuidedMode'); ipcMain.handle('setGuidedMode', (event, newGuidedMode: boolean) => { store.set('guidedMode', newGuidedMode); guidedMode = newGuidedMode; }); let smuggleCostumeIndex = store.get('smuggleCostumeIndex', true); setOwnSmuggleCostumeIndex(smuggleCostumeIndex); ipcMain.removeHandler('getSmuggleCostumeIndex'); ipcMain.handle('getSmuggleCostumeIndex', () => smuggleCostumeIndex); ipcMain.removeHandler('setSmuggleCostumeIndex'); ipcMain.handle( 'setSmuggleCostumeIndex', (event, newSmuggleCostumeIndex: boolean) => { store.set('smuggleCostumeIndex', newSmuggleCostumeIndex); smuggleCostumeIndex = newSmuggleCostumeIndex; setOwnSmuggleCostumeIndex(smuggleCostumeIndex); }, ); ipcMain.removeHandler('copyToClipboard'); ipcMain.handle('copyToClipboard', (event, text: string) => { clipboard.writeText(text); }); ipcMain.removeHandler('getVersion'); ipcMain.handle('getVersion', () => app.getVersion()); ipcMain.removeHandler('getLatestVersion'); ipcMain.handle('getLatestVersion', async () => { try { const response = await fetch( 'https://api.github.com/repos/jmlee337/replay-manager-for-slippi/releases/latest', ); const json = await response.json(); const latestVersion = json.tag_name; if (typeof latestVersion !== 'string') { return ''; } return latestVersion; } catch { throw new Error('***You may not be connected to the internet***'); } }); ipcMain.removeHandler('update'); ipcMain.handle('update', async () => { await shell.openExternal( 'https://github.com/jmlee337/replay-manager-for-slippi/releases/latest', ); app.quit(); }); ipcMain.on( 'sendEnforcerResults', ( event, results: { fileName: string; playerFailures: EnforcePlayerFailure[] }[], enforcerReplayLoadCount: number, ) => { const fileNameToPlayerFailures = new Map( results.map(({ fileName, playerFailures }) => [ fileName, playerFailures, ]), ); const doneState: EnforceState = { status: EnforceStatus.DONE, fileNameToPlayerFailures, }; mainWindow.webContents.send( 'enforceState', doneState, enforcerReplayLoadCount, ); }, ); ipcMain.on( 'sendEnforcerError', (event, reason: any, enforcerReplayLoadCount: number) => { const errorState: EnforceState = { status: EnforceStatus.ERROR, fileNameToPlayerFailures: new Map(), reason, }; mainWindow.webContents.send( 'enforceState', errorState, enforcerReplayLoadCount, ); }, ); ipcMain.on('openEntrantsWindow', () => { if (entrantsWindow) { entrantsWindow.moveTop(); entrantsWindow.focus(); return; } entrantsWindow = new BrowserWindow({ width: 880, webPreferences: { preload: app.isPackaged ? path.join(__dirname, 'preload.js') : path.join(__dirname, '../../.erb/dll/preload.js'), }, }); entrantsWindow.loadURL(resolveHtmlPath('entrants.html')); entrantsWindow.on('close', () => { entrantsWindow = null; }); }); app.on('will-quit', (event) => { detectUsb.stopListening(); stopListening(); deafenForOfflineMode(); if (undoSrcFullPath) { event.preventDefault(); (async () => { try { await rm(undoDstFullPath, { force: true, recursive: true }); } catch { // just catch } finally { undoSrcFullPath = ''; app.quit(); } })(); return; } if (isBroadcasting()) { event.preventDefault(); (async () => { await stopBroadcasting(); app.quit(); })(); } }); }