435 lines
No EOL
14 KiB
TypeScript
435 lines
No EOL
14 KiB
TypeScript
import path from 'node:path';
|
|
import { Glob, which } from 'bun';
|
|
import fs from 'node:fs/promises';
|
|
import { existsSync, readFileSync } from 'node:fs';
|
|
import * as schema from '@schema/emulators';
|
|
import { eq } from 'drizzle-orm';
|
|
import { config, customEmulators, emulatorsDb, taskQueue } from '../../app';
|
|
import os, { platform } from 'node:os';
|
|
import { cores } from '../../emulatorjs/emulatorjs';
|
|
import { LaunchGameJob } from '../../jobs/launch-game-job';
|
|
import { EmulatorPackageType } from '@/shared/constants';
|
|
import { getStoreEmulatorPackage, getStoreFolder } from '../../store/services/gamesService';
|
|
import { getOrCached } from '../../cache';
|
|
import { getOrCachedScoopPackage } from '../../store/services/emulatorsService';
|
|
|
|
export const varRegex = /%([^%]+)%/g;
|
|
export const assignRegex = /(%\w+%)=(\S+) /g;
|
|
|
|
export async function launchCommand (validCommand: CommandEntry, source: string, sourceId: string, id: number)
|
|
{
|
|
if (taskQueue.hasActiveOfType(LaunchGameJob))
|
|
{
|
|
throw new Error(`${id} currently running`);
|
|
}
|
|
|
|
taskQueue.enqueue(LaunchGameJob.id, new LaunchGameJob(id, validCommand, source, sourceId));
|
|
}
|
|
|
|
/**
|
|
* Get the emulators related to the given system
|
|
* @param systemSlug the ES-DE slug for the system
|
|
*/
|
|
export async function getEmulatorsForSystem (systemSlug: string)
|
|
{
|
|
const system = await emulatorsDb.query.systems.findFirst({
|
|
with: { commands: true },
|
|
where: eq(schema.systems.name, systemSlug)
|
|
});
|
|
|
|
if (!system)
|
|
{
|
|
throw new Error(`Could not find system '${systemSlug}'`);
|
|
}
|
|
|
|
const emulators = new Set<string>();
|
|
await Promise.all(system.commands.map(async (command, index) =>
|
|
{
|
|
let cmd = command.command;
|
|
|
|
const matches = Array.from(cmd.matchAll(varRegex));
|
|
matches.forEach(([value]) =>
|
|
{
|
|
if (value.startsWith("%EMULATOR_"))
|
|
{
|
|
const emulatorName = value.substring("%EMULATOR_".length, value.length - 1);
|
|
emulators.add(emulatorName);
|
|
return;
|
|
}
|
|
});
|
|
}));
|
|
|
|
|
|
|
|
if (cores[systemSlug])
|
|
{
|
|
emulators.add('EMULATORJS');
|
|
}
|
|
|
|
return Array.from(emulators);
|
|
}
|
|
|
|
/**
|
|
*
|
|
* @param data Uses es-de system slug
|
|
* @returns
|
|
*/
|
|
export async function getValidLaunchCommands (data: {
|
|
systemSlug: string;
|
|
gamePath: string;
|
|
}): Promise<CommandEntry[]>
|
|
{
|
|
|
|
const system = await emulatorsDb.query.systems.findFirst({
|
|
with: { commands: true },
|
|
where: eq(schema.systems.name, data.systemSlug)
|
|
});
|
|
|
|
if (!system)
|
|
{
|
|
throw new Error(`Could not find system '${data.systemSlug}'`);
|
|
}
|
|
|
|
if (!system.extension || system.extension.length <= 0)
|
|
{
|
|
throw new Error(`No extensions listed for system '${data.systemSlug}'`);
|
|
}
|
|
|
|
const downloadPath = config.get('downloadPath');
|
|
const gamePath = path.join(downloadPath, data.gamePath);
|
|
|
|
const validFiles: string[] = [];
|
|
if (!existsSync(gamePath))
|
|
{
|
|
throw new Error(`Provided rom path is missing: '${gamePath}'`);
|
|
}
|
|
|
|
const gamePathStat = await fs.stat(gamePath);
|
|
|
|
const extensionList = system.extension.join(',');
|
|
|
|
if (gamePathStat.isDirectory())
|
|
{
|
|
for await (const file of fs.glob(path.join(gamePath, `/**/*.{${extensionList}}`)))
|
|
{
|
|
validFiles.push(file);
|
|
}
|
|
|
|
if (validFiles.length <= 0)
|
|
{
|
|
throw new Error(`Could not find valid rom file. Must be a file that ends in '${extensionList}'`);
|
|
}
|
|
} else
|
|
{
|
|
if (system.extension.some(e => gamePath.toLocaleLowerCase().endsWith(e.toLocaleLowerCase())))
|
|
{
|
|
validFiles.push(gamePath);
|
|
}
|
|
else
|
|
{
|
|
throw new Error(`Invalid Rom File. Must be a file that ends in '${extensionList}'`);
|
|
}
|
|
}
|
|
|
|
function escapeWindowsArg (arg: string): string
|
|
{
|
|
if (process.platform === 'win32')
|
|
{
|
|
return `"${arg
|
|
.replace(/(\\*)"/g, '$1$1\\"') // escape quotes
|
|
.replace(/(\\*)$/, '$1$1') // escape trailing backslashes
|
|
}"`;
|
|
} else
|
|
{
|
|
if (arg.includes(' '))
|
|
{
|
|
return `"${arg}"`;
|
|
} else
|
|
{
|
|
return arg;
|
|
}
|
|
}
|
|
}
|
|
|
|
const formattedCommands = await Promise.all(system.commands
|
|
.filter(c => !c.command.includes(`%ENABLESHORTCUTS%`))
|
|
.map(async (command, index) =>
|
|
{
|
|
const label = command.label;
|
|
let cmd = command.command;
|
|
|
|
let emulator: string | undefined = undefined;
|
|
let rom = validFiles[0];
|
|
|
|
if (cmd.includes('%ESCAPESPECIALS%'))
|
|
rom = rom.replace(/[&()^=;,]/g, '');
|
|
|
|
|
|
|
|
const staticVars: Record<string, string> = {
|
|
'%ROM%': escapeWindowsArg(rom),
|
|
'%ROMRAW%': validFiles[0],
|
|
'%ROMRAWWIN%': escapeWindowsArg(validFiles[0].replaceAll('/', '\\')),
|
|
'%ESPATH%': escapeWindowsArg(path.dirname(Bun.main)),
|
|
'%ROMPATH%': escapeWindowsArg(gamePath),
|
|
'%BASENAME%': escapeWindowsArg(path.basename(validFiles[0], path.extname(validFiles[0]))),
|
|
'%FILENAME%': escapeWindowsArg(path.basename(validFiles[0])),
|
|
'%ESCAPESPECIALS%': "",
|
|
'%HIDEWINDOW%': ""
|
|
};
|
|
|
|
cmd = cmd.replace(/\%INJECT\%=(?<inject>[\w\%.\/\\]+)/g, (_, injectFile: string) =>
|
|
{
|
|
try
|
|
{
|
|
const resolvedInjectFile = injectFile.replace(varRegex, (a) =>
|
|
{
|
|
return staticVars[a] ?? a;
|
|
});
|
|
if (existsSync(resolvedInjectFile))
|
|
{
|
|
const rawContents = readFileSync(resolvedInjectFile, { encoding: 'utf-8' });
|
|
return rawContents.split('\n').map(v => v.replace('\r', '')).join(' ');
|
|
}
|
|
|
|
return '';
|
|
} catch (error)
|
|
{
|
|
return '';
|
|
}
|
|
});
|
|
|
|
const matches = Array.from(cmd.matchAll(varRegex));
|
|
const varList = await Promise.all(matches.map(async ([value]) =>
|
|
{
|
|
if (value.startsWith("%EMULATOR_"))
|
|
{
|
|
const emulatorName = value.substring("%EMULATOR_".length, value.length - 1);
|
|
let execs = await findExecsByName(emulatorName);
|
|
let validExec = execs.find(e => e.exists);
|
|
|
|
emulator = emulatorName;
|
|
return [
|
|
[value, validExec ? validExec.binPath : undefined] as [string, string | undefined],
|
|
[`%EMUSOURCE%`, validExec?.type] as [string, string | undefined],
|
|
['%EMUDIR%', validExec?.rootPath ?? (validExec ? escapeWindowsArg(path.dirname(validExec.binPath)) : undefined)] as [string, string | undefined],
|
|
['%EMUDIRRAW%', validExec?.rootPath ?? (validExec ? path.dirname(validExec.binPath) : undefined)] as [string, string | undefined]
|
|
];
|
|
|
|
}
|
|
|
|
const key = value[0].substring(1, value.length - 1);
|
|
return [[value, process.env[key]] as [string, string | undefined]];
|
|
}));
|
|
|
|
const vars = { ...Object.fromEntries(varList.flatMap(l => l)), ...staticVars };
|
|
let startDir: string | undefined = undefined;
|
|
|
|
if ('%STARTDIR%' in vars)
|
|
{
|
|
delete vars['%STARTDIR%'];
|
|
|
|
cmd = cmd.replace(assignRegex, (match, p1, p2) =>
|
|
{
|
|
if (p1 === '%STARTDIR%')
|
|
{
|
|
startDir = varRegex.test(p2) ? staticVars[p2] : p2;
|
|
}
|
|
return "";
|
|
});
|
|
}
|
|
|
|
// missing variable
|
|
const invalid = Object.entries(vars).find(c => c[1] === undefined);
|
|
|
|
const formattedCommand = cmd.replace(varRegex, (s) => vars[s] ?? '').trim();
|
|
|
|
return {
|
|
id: index,
|
|
label: label ?? undefined,
|
|
command: formattedCommand,
|
|
startDir,
|
|
valid: !invalid, emulator,
|
|
emulatorSource: vars['%EMUSOURCE%'] as any,
|
|
metadata: {
|
|
romPath: validFiles[0],
|
|
emulatorBin: varList.flatMap(l => l).find(v => v[0].includes('%EMULATOR_'))?.[1],
|
|
emulatorDir: vars['%EMUDIRRAW%']
|
|
}
|
|
} satisfies CommandEntry;
|
|
}));
|
|
|
|
return formattedCommands.filter(c => !!c);
|
|
}
|
|
|
|
export async function findExecsByName (emulatorName: string)
|
|
{
|
|
const emulator = await emulatorsDb.query.emulators.findFirst({ where: eq(schema.emulators.name, emulatorName) });
|
|
if (!emulator)
|
|
{
|
|
throw new Error(`Could not find emulator ${emulatorName}`);
|
|
}
|
|
return findExecs(emulatorName, emulator);
|
|
}
|
|
|
|
export async function findStoreEmulatorExec (id: string, emulator?: { systempath: string[]; }): Promise<EmulatorSourceEntryType | undefined>
|
|
{
|
|
const storeEmulatorFolder = path.join(config.get('downloadPath'), 'emulators', id);
|
|
const storeExecName = emulator?.systempath.find(name => existsSync(path.join(storeEmulatorFolder, name)));
|
|
if (storeExecName)
|
|
{
|
|
return { binPath: path.join(storeEmulatorFolder, storeExecName), rootPath: storeEmulatorFolder, exists: true, type: "store" };
|
|
}
|
|
|
|
const storeEmulator = await getStoreEmulatorPackage(id);
|
|
if (storeEmulator?.downloads)
|
|
{
|
|
const storeExecName = (await Promise.all(storeEmulator.downloads[`${process.platform}:${process.arch}`].map(async dl =>
|
|
{
|
|
// glob file search causes issues so do manual search
|
|
if (await fs.exists(storeEmulatorFolder))
|
|
{
|
|
const glob = (dl as any).pattern ? new Glob((dl as any).pattern) : undefined;
|
|
let bin: string | undefined = (dl as any).bin;
|
|
if (!bin && dl.type === 'scoop')
|
|
{
|
|
const data = await getOrCachedScoopPackage(id, dl.url);
|
|
|
|
if (data)
|
|
{
|
|
bin = data.bin;
|
|
}
|
|
}
|
|
|
|
const files = (await fs.readdir(storeEmulatorFolder))
|
|
.filter(f =>
|
|
{
|
|
if (glob && glob.match(f)) return true;
|
|
if (bin && f === bin) return true;
|
|
});
|
|
|
|
return files.map(f => path.join(storeEmulatorFolder, f));
|
|
}
|
|
return [];
|
|
|
|
}))).flatMap(f => f);
|
|
|
|
if (storeExecName.length > 0)
|
|
{
|
|
return { binPath: storeExecName[0], rootPath: storeEmulatorFolder, exists: true, type: 'store' };
|
|
}
|
|
}
|
|
|
|
|
|
return undefined;
|
|
}
|
|
|
|
export async function findExecs (id: string, emulator?: { winregistrypath: string[], systempath: string[], staticpath: string[]; })
|
|
{
|
|
const execs: EmulatorSourceEntryType[] = [];
|
|
|
|
if (customEmulators.has(id))
|
|
{
|
|
execs.push({ binPath: customEmulators.get(id), type: 'custom', exists: await fs.exists(customEmulators.get(id)) });
|
|
}
|
|
|
|
if (emulator && emulator.systempath.length > 0)
|
|
{
|
|
const storePath = await findStoreEmulatorExec(id, emulator);
|
|
if (storePath) execs.push(storePath);
|
|
}
|
|
|
|
if (emulator && os.platform() === 'win32')
|
|
{
|
|
const regValues = emulator.winregistrypath;
|
|
if (regValues.length > 0)
|
|
{
|
|
for (const node of regValues)
|
|
{
|
|
const registryValue = await readRegistryValue(node);
|
|
if (registryValue)
|
|
{
|
|
execs.push({ binPath: registryValue, type: 'registry', exists: true });
|
|
}
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
if (emulator && emulator.systempath.length > 0)
|
|
{
|
|
const systemPath = await resolveSystemPath(emulator.systempath);
|
|
if (systemPath)
|
|
{
|
|
execs.push({ binPath: systemPath, type: 'system', exists: true });
|
|
}
|
|
}
|
|
|
|
if (emulator && emulator.staticpath.length > 0)
|
|
{
|
|
const staticPath = await resolveStaticPath(emulator.staticpath);
|
|
if (staticPath)
|
|
{
|
|
execs.push({ binPath: staticPath, type: 'static', exists: true });
|
|
}
|
|
}
|
|
|
|
return execs;
|
|
}
|
|
|
|
async function readRegistryValue (text: string)
|
|
{
|
|
const params = text.split('|');
|
|
const key = path.dirname(params[0]);
|
|
const value = path.basename(params[0]);
|
|
const bin = params.length > 1 ? params[1] : undefined;
|
|
|
|
const proc = Bun.spawn({
|
|
cmd: ["reg", "QUERY", key, "/v", value],
|
|
stdout: "pipe",
|
|
stderr: "pipe",
|
|
});
|
|
|
|
const output = await new Response(proc.stdout).text();
|
|
await proc.exited;
|
|
|
|
if (!output.includes(value)) return null;
|
|
|
|
const lines = output.split("\n");
|
|
for (const line of lines)
|
|
{
|
|
if (line.includes(value))
|
|
{
|
|
const parts = line.trim().split(/\s{4,}/);
|
|
return bin ? path.join(parts[2], bin) : parts[2]; // registry value
|
|
}
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
async function resolveStaticPath (entries: string[])
|
|
{
|
|
for (const entry of entries)
|
|
{
|
|
const resolved = entry.replace("~", os.homedir());
|
|
if (await fs.exists(resolved))
|
|
{
|
|
return resolved;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
async function resolveSystemPath (entries: string[])
|
|
{
|
|
for (const entry of entries)
|
|
{
|
|
try
|
|
{
|
|
const found = which(entry);
|
|
return found;
|
|
} catch { }
|
|
}
|
|
return null;
|
|
} |