simeonradivoev/gameflow-deck
simeonradivoev/gameflow-deck
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat: implemented storage management

Browse source 
fix: Enabled fallback secrets
feat: Made header stats actually work
feat: Made steam deck keyboard auto open for some inputs
fix: Made keybaord also work with shortcuts (no tooltips yet)
This commit is contained in:
Simeon Radivoev 2026-02-24 00:30:16 +02:00
parent 62f16cbcc1
commit e4df8fb9fb
Signed by: simeonradivoev
GPG key ID: C16C2132A7660C8E
55 changed files with 1675 additions and 398 deletions
Download patch file Download diff file Expand all files Collapse all files

16
src/bun/api/app.ts
View file

@ -19,6 +19,7 @@ import { ActiveGame } from "../types/types";
import EventEmitter from "node:events";
import { ErrorLike } from "bun";
import { getErrorMessage } from "../utils";
import { DrizzleSqliteDODatabase } from "drizzle-orm/durable-sqlite";
export const config = new Conf<SettingsType>({
projectName: projectPackage.name,
@ -44,9 +45,10 @@ const fileCookieStore = new FileCookieStore(path.join(path.dirname(config.path),
console.log("Cookie Jar Path Located At: ", fileCookieStore.filePath);
export const jar = new CookieJar(fileCookieStore);
await fs.mkdir(config.get('downloadPath'), { recursive: true });
const sqlite = new Database(path.join(config.get('downloadPath'), 'db.sqlite'), { create: true, readwrite: true });
export const db = drizzle(sqlite, { schema });
migrate(db, { migrationsFolder: "./drizzle" });
let sqlite: Database;
export let db: DrizzleSqliteDODatabase<typeof schema>;
await reloadDatabase();
migrate(db!, { migrationsFolder: "./drizzle" });
const emulatorsSqlite = new Database(`./vendors/es-de/emulators.${os.platform()}.${os.arch()}.sqlite`, { readonly: true });
export const emulatorsDb = drizzle(emulatorsSqlite, { schema: emulatorSchema });
export const taskQueue = new TaskQueue();
@ -77,9 +79,15 @@ export async function cleanup ()
emulatorsSqlite.close();
}
export async function reloadDatabase ()
{
sqlite = new Database(path.join(config.get('downloadPath'), 'db.sqlite'), { create: true, readwrite: true });
db = drizzle(sqlite, { schema });
}
interface AppEventMap
{
activegameexit: [{ subprocess?: Bun.Subprocess, exitCode: number | null, signalCode: number | null, error?: ErrorLike; }];
activegameexit: [{ source: string, id: number, subprocess?: Bun.Subprocess, exitCode: number | null, signalCode: number | null, error?: ErrorLike; }];
exitapp: [];
notification: [Notification];
}

91
src/bun/api/drives.ts Normal file
View file

@ -0,0 +1,91 @@
import { Drive } from "@/shared/constants";
import si from 'systeminformation';
import fs from 'node:fs';
import os from "node:os";
async function getAccess (path: string)
{
let hasWriteAccess = false;
try
{
await fs.promises.access(path, fs.constants.W_OK);
hasWriteAccess = true;
} catch (error)
{
}
let hasReadAccesss = false;
try
{
await fs.promises.access(path, fs.constants.R_OK);
hasReadAccesss = true;
} catch (error)
{
}
return [hasReadAccesss, hasWriteAccess];
}
export async function getDevices (): Promise<Drive[]>
{
const blockDevicesRaw = await si.blockDevices();
const layout = await si.diskLayout();
const blockDevices = blockDevicesRaw.filter(l => l.device && l.type === 'part' && l.mount);
const fsSizes = await si.fsSize();
const sizes = new Map(fsSizes.map(s => [s.mount, s]));
const layoutMap = new Map(layout.map(l => [l.device, l]));
return await Promise.all(blockDevices.map(async l =>
{
const size = sizes.get(l.mount);
const layout = layoutMap.get(l.device!);
const [hasReadAccess, hasWriteAccess] = await getAccess(l.mount);
const drive: Drive = {
parent: l.group || null,
device: l.device ?? '',
label: l.label || l.name,
mountPoint: l.mount,
type: l.type as any,
size: l.size,
used: size?.used ?? l.size,
isRemovable: l.removable,
interfaceType: layout?.interfaceType || null,
hasReadAccess,
hasWriteAccess
};
return drive;
}));
}
// Gets hand picked locations on drives that you have permission to write to
export async function getDevicesCurated (): Promise<Drive[]>
{
const drives: Drive[] = [];
const devices = await getDevices();
drives.push(...devices.filter(d => d.hasWriteAccess));
const homeDir = os.homedir();
const homeDirDevice = devices.filter(d => d.mountPoint).reverse()
.find(d => homeDir.startsWith(d.mountPoint!));
if (homeDirDevice)
{
const [hasReadAccess, hasWriteAccess] = await getAccess(homeDir);
drives.push({
parent: homeDirDevice.parent,
device: homeDirDevice.device,
size: homeDirDevice.size,
used: homeDirDevice.used,
isRemovable: homeDirDevice.isRemovable,
mountPoint: homeDir,
type: homeDirDevice.type,
label: 'Home',
interfaceType: homeDirDevice.interfaceType,
hasReadAccess,
hasWriteAccess
});
}
return drives;
}

173
src/bun/api/games/games.ts
View file

@ -4,15 +4,15 @@ import { and, eq, getTableColumns } from "drizzle-orm";
import z from "zod";
import * as schema from "../schema/app";
import fs from "node:fs/promises";
import { FrontEndGameType, FrontEndGameTypeDetailed } from "@shared/constants";
import { FrontEndGameType, FrontEndGameTypeDetailed, GameListFilterSchema } from "@shared/constants";
import { getRomApiRomsIdGet, getRomsApiRomsGet, updateRomUserApiRomsIdPropsPut } from "@clients/romm";
import { InstallJob } from "../jobs/install-job";
import path from "node:path";
import { calculateSize, checkInstalled, convertRomToFrontend, convertRomToFrontendDetailed, getLocalGameMatch } from "./services/utils";
import buildStatusResponse, { getValidLaunchCommandsForGame } from "./services/statusService";
import { errorToResponse } from "elysia/adapter/bun/handler";
import { launchCommand } from "./services/launchGameService";
import { getErrorMessage } from "@/bun/utils";
import { spawn } from "node:child_process";
export default new Elysia()
.get('/game/local/:id/cover', async ({ params: { id }, set }) =>
@ -55,54 +55,64 @@ export default new Elysia()
}, {
params: z.object({ id: z.number() }),
response: z.object({ installed: z.boolean() })
}).get('/games', async ({ query: { platform_id, collection_id } }) =>
}).get('/games', async ({ query: { platform_source, platform_slug, platform_id, collection_id } }) =>
{
const where: any[] = [];
if (platform_id)
if (platform_slug)
{
where.push(eq(schema.games.id, platform_id));
where.push(eq(schema.platforms.slug, platform_slug));
}
const games: FrontEndGameType[] = [];
let localGamesSet: Set<number> | undefined;
const localGames = await db.select({
platform_display_name: schema.platforms.name,
id: schema.games.id,
last_played: schema.games.last_played,
created_at: schema.games.created_at,
platform_id: schema.games.platform_id,
slug: schema.games.slug,
name: schema.games.name,
path_fs: schema.games.path_fs,
source_id: schema.games.source_id,
source: schema.games.source
}).from(schema.games).leftJoin(schema.platforms, eq(schema.games.platform_id, schema.platforms.id)).where(and(...where));
const localGamesSet = new Set(localGames.map(g => g.source_id));
games.push(...localGames.map(g =>
if (!collection_id)
{
const game: FrontEndGameType = {
...g,
platform_display_name: g.platform_display_name ?? "Local",
id: { id: g.id, source: 'local' },
updated_at: g.created_at,
path_cover: `/api/romm/game/local/${g.id}/cover`,
source_id: g.source_id,
source: g.source,
path_platform_cover: `/api/romm/platform/local/${g.platform_id}/cover`
};
return game;
}));
const localGames = await db.select({
platform_display_name: schema.platforms.name,
id: schema.games.id,
last_played: schema.games.last_played,
created_at: schema.games.created_at,
platform_id: schema.games.platform_id,
slug: schema.games.slug,
name: schema.games.name,
path_fs: schema.games.path_fs,
source_id: schema.games.source_id,
source: schema.games.source
}).from(schema.games)
.leftJoin(schema.platforms, eq(schema.games.platform_id, schema.platforms.id))
.where(and(...where));
const rommGames = await getRomsApiRomsGet({ query: { platform_ids: platform_id ? [platform_id] : undefined, collection_id }, throwOnError: true });
games.push(...rommGames.data.items.filter(g => !localGamesSet.has(g.id)).map(g =>
localGamesSet = new Set(localGames.filter(g => !!g.source_id).map(g => g.source_id!));
games.push(...localGames.map(g =>
{
const game: FrontEndGameType = {
...g,
platform_display_name: g.platform_display_name ?? "Local",
id: { id: g.id, source: 'local' },
updated_at: g.created_at,
path_cover: `/api/romm/game/local/${g.id}/cover`,
source_id: g.source_id,
source: g.source,
path_platform_cover: `/api/romm/platform/local/${g.platform_id}/cover`
};
return game;
}));
}
if ((!platform_source || platform_source === 'romm') || !!collection_id)
{
return convertRomToFrontend(g);
}));
const rommGames = await getRomsApiRomsGet({ query: { platform_ids: platform_id ? [platform_id] : undefined, collection_id }, throwOnError: true });
games.push(...rommGames.data.items.filter(g => !localGamesSet?.has(g.id)).map(g =>
{
return convertRomToFrontend(g);
}));
}
return { games };
}, {
query: z.object({ platform_id: z.coerce.number().optional(), collection_id: z.coerce.number().optional() }),
query: GameListFilterSchema,
})
.get('/game/:source/:id', async ({ params: { source, id } }) =>
{
@ -188,7 +198,7 @@ export default new Elysia()
{
if (!taskQueue.hasActive())
{
taskQueue.enqueue(`install-rom-${source}-${id}`, new InstallJob(id));
taskQueue.enqueue(`install-rom-${source}-${id}`, new InstallJob(id, source, id));
return status(200);
} else
{
@ -209,97 +219,14 @@ export default new Elysia()
}
else
{
if (activeGame && activeGame.process.killed === false)
{
return status('Conflict', `${activeGame.name} currently running`);
}
const localGame = await db.query.games.findFirst({
where: eq(schema.games.id, validCommand.gameId), columns: {
name: true,
source_id: true,
source: true
}
});
try
{
await new Promise((resolve, reject) =>
{
const game = spawn(validCommand.command.command, {
shell: true
});
game.stdout.on('data', data => console.log(data));
game.on('close', (code) =>
{
events.emit('activegameexit', { exitCode: code, signalCode: null });
resolve(code);
});
game.on('error', e =>
{
events.emit('activegameexit', { exitCode: null, signalCode: null, error: e });
console.error(e);
});
setActiveGame({
pid: game.pid,
name: localGame?.name ?? "Unknown",
gameId: validCommand.gameId,
command: validCommand.command.command
});
function updateRommProps (id: number)
{
updateRomUserApiRomsIdPropsPut({ path: { id }, body: { update_last_played: true } });
events.emit('notification', { message: "Updated Last Played", type: 'success' });
}
if (source === 'romm')
{
updateRommProps(id);
}
else if (localGame?.source === 'romm' && localGame.source_id)
{
updateRommProps(localGame.source_id);
}
});
/*
const cmd = Array.from(validCommand.command.command.matchAll(/(".*?"|[^\s"]+)/g)).map(m => m[0]);
const game = setActiveGame({
process: Bun.spawn({
cmd,
env: {
...process.env
},
onExit (subprocess, exitCode, signalCode, error)
{
events.emit('activegameexit', { subprocess, exitCode, signalCode, error });
},
stdin: "ignore",
stdout: "inherit",
stderr: "inherit",
}),
name: localGame?.name ?? "Unknown",
gameId: validCommand.gameId,
command: validCommand.command.command
});
await game.process.exited;
if (game.process.exitCode && game.process.exitCode > 0)
{
return status('Internal Server Error');
}*/
return status('OK');
await launchCommand(validCommand.command.command, source, id, validCommand.gameId);
} catch (error)
{
console.error(error);
return status('Internal Server Error', getErrorMessage(error));
}
}
}
}, {

22
src/bun/api/games/platforms.ts
View file

@ -12,6 +12,14 @@ export default new Elysia()
const platforms: FrontEndPlatformType[] = [];
let rommPlatformsSet: Set<string> | undefined;
const { data: rommPlatforms } = await getPlatformsApiPlatformsGet();
const localPlatforms = await db.select({ ...getTableColumns(schema.platforms), game_count: count(schema.games.id) })
.from(schema.platforms)
.leftJoin(schema.games, eq(schema.games.platform_id, schema.platforms.id))
.groupBy(schema.platforms.id);
const localPlatformSet = new Set(localPlatforms.filter(p => p.game_count > 0).map(p => p.slug));
if (rommPlatforms)
{
const frontEndPlatforms = rommPlatforms.map(p =>
@ -24,22 +32,17 @@ export default new Elysia()
game_count: p.rom_count,
updated_at: new Date(p.updated_at),
id: { source: 'romm', id: p.id },
source: null,
source_id: null
hasLocal: localPlatformSet.has(p.slug)
};
return platform;
});
rommPlatformsSet = new Set(rommPlatforms.map(p => p.slug));
platforms.push(...frontEndPlatforms);
}
const localPlatforms = await db.select({ ...getTableColumns(schema.platforms), game_count: count(schema.games.id) })
.from(schema.platforms)
.leftJoin(schema.games, eq(schema.games.platform_id, schema.platforms.id))
.groupBy(schema.platforms.id)
.where(notInArray(schema.platforms.slug, Array.from(rommPlatformsSet ?? [])));
platforms.push(...localPlatforms.map(p =>
platforms.push(...localPlatforms.filter(p => !rommPlatformsSet?.has(p.slug)).map(p =>
{
const platform: FrontEndPlatformType = {
slug: p.slug,
@ -49,8 +52,7 @@ export default new Elysia()
game_count: p.game_count,
updated_at: p.created_at,
id: { source: 'local', id: p.id },
source: null,
source_id: null
hasLocal: true
};
return platform;

99
src/bun/api/games/services/launchGameService.ts
View file

@ -3,10 +3,13 @@ import { which } from 'bun';
import fs from 'node:fs/promises';
import { existsSync, readFileSync } from 'node:fs';
import * as schema from '../../schema/emulators';
import * as appSchema from "../../schema/app";
import { eq } from 'drizzle-orm';
import { config, emulatorsDb } from '../../app';
import { activeGame, config, db, emulatorsDb, events, setActiveGame } from '../../app';
import os from 'node:os';
import { $ } from 'bun';
import { spawn } from 'node:child_process';
import { updateRomUserApiRomsIdPropsPut } from '@/clients/romm';
export const varRegex = /%([^%]+)%/g;
@ -18,6 +21,92 @@ interface CommandEntry
emulator?: string;
}
export async function launchCommand (validCommand: string, source: string, sourceId: number, id: number)
{
if (activeGame && activeGame.process?.killed === false)
{
throw new Error(`${activeGame.name} currently running`);
}
const localGame = await db.query.games.findFirst({
where: eq(appSchema.games.id, id), columns: {
name: true,
source_id: true,
source: true
}
});
await new Promise((resolve, reject) =>
{
const game = spawn(validCommand, {
shell: true
});
game.stdout.on('data', data => console.log(data));
game.on('close', (code) =>
{
events.emit('activegameexit', { source, id: sourceId, exitCode: code, signalCode: null });
resolve(code);
});
game.on('error', e =>
{
console.error(e);
events.emit('notification', { message: e.message, type: 'error' });
reject(e);
});
setActiveGame({
process: game,
name: localGame?.name ?? "Unknown",
gameId: id,
command: validCommand
});
function updateRommProps (id: number)
{
updateRomUserApiRomsIdPropsPut({ path: { id }, body: { update_last_played: true } });
events.emit('notification', { message: "Updated Last Played", type: 'success' });
}
if (source === 'romm')
{
updateRommProps(sourceId);
}
else if (localGame?.source === 'romm' && localGame.source_id)
{
updateRommProps(localGame.source_id);
}
});
/* Old spawn lanching, cases issues, needs to be ran as shell
const cmd = Array.from(validCommand.command.command.matchAll(/(".*?"|[^\s"]+)/g)).map(m => m[0]);
const game = setActiveGame({
process: Bun.spawn({
cmd,
env: {
...process.env
},
onExit (subprocess, exitCode, signalCode, error)
{
events.emit('activegameexit', { subprocess, exitCode, signalCode, error });
},
stdin: "ignore",
stdout: "inherit",
stderr: "inherit",
}),
name: localGame?.name ?? "Unknown",
gameId: validCommand.gameId,
command: validCommand.command.command
});
await game.process.exited;
if (game.process.exitCode && game.process.exitCode > 0)
{
return status('Internal Server Error');
}*/
}
export async function getValidLaunchCommands (data: {
systemSlug: string;
gamePath: string;
@ -90,11 +179,11 @@ export async function getValidLaunchCommands (data: {
const staticVars: Record<string, string> = {
'%ROM%': $.escape(rom),
'%ROMRAW%': validFiles[0],
'%ROMRAWWIN%': validFiles[0].replace('/', '\\'),
'%ESPATH%': path.dirname(Bun.main),
'%ROMRAWWIN%': $.escape(validFiles[0].replace('/', '\\')),
'%ESPATH%': $.escape(path.dirname(Bun.main)),
'%ROMPATH%': $.escape(gamePath),
'%BASENAME%': path.basename(validFiles[0], path.extname(validFiles[0])),
'%FILENAME%': path.basename(validFiles[0])
'%BASENAME%': $.escape(path.basename(validFiles[0], path.extname(validFiles[0]))),
'%FILENAME%': $.escape(path.basename(validFiles[0]))
};
cmd = cmd.replace(/\%INJECT\%=(?<inject>[\w\%.\/\\]+)/g, (subscring, injectFile: string) =>

27
src/bun/api/games/services/statusService.ts
View file

@ -79,19 +79,39 @@ export async function getValidLaunchCommandsForGame (source: string, id: number)
export default async function buildStatusResponse (source: string, id: number)
{
let cleanup: (() => void) | undefined;
let closed = false;
return new Response(new ReadableStream({
async start (controller)
{
function enqueue (data: GameInstallProgress, event?: 'error' | 'refresh')
const encoder = new TextEncoder();
function enqueue (data: GameInstallProgress, event?: 'error' | 'refresh' | 'ping')
{
const evntString = event ? `event: ${event}\n` : '';
controller.enqueue(`${evntString}data: ${JSON.stringify(data)}\n\n`);
controller.enqueue(encoder.encode(`${evntString}data: ${JSON.stringify(data)}\n\n`));
}
await sendLatests();
// seems to help with issue of buffers not flushing, keeping the connection open forcefully
const keepAlive = setInterval(() =>
{
if (closed) return clearInterval(keepAlive);
try
{
enqueue({}, 'ping');
} catch
{
closed = true;
clearInterval(keepAlive);
}
}, 15000);
const sourceId = `${source}-${id}`;
async function sendLatests ()
{
if (closed) return;
const localGame = await db.query.games.findFirst({ where: getLocalGameMatch(id, source), columns: { id: true } });
const activeTask = taskQueue.findJob(`install-rom-${source}-${id}`);
if (activeTask)
@ -136,8 +156,6 @@ export default async function buildStatusResponse (source: string, id: number)
}
}
await sendLatests();
const dispose: Function[] = [];
const handleActiveExit = async (data: { error?: ErrorLike; }) =>
{
@ -179,6 +197,7 @@ export default async function buildStatusResponse (source: string, id: number)
cleanup = () =>
{
closed = true;
dispose.forEach(f => f());
};
},

11
src/bun/api/jobs/install-job.ts
View file

@ -2,16 +2,13 @@ import { IJob, JobContext } from "../task-queue";
import { mkdir } from 'node:fs/promises';
import { and, eq, or } from 'drizzle-orm';
import fs from 'node:fs/promises';
import { DownloaderHelper } from 'node-downloader-helper';
import StreamZip from 'node-stream-zip';
import * as schema from "../schema/app";
import * as emulatorSchema from "../schema/emulators";
import path from 'node:path';
import { downloadRomsApiRomsDownloadGet, getPlatformApiPlatformsIdGet, getRomApiRomsIdGet } from "@clients/romm";
import { getPlatformApiPlatformsIdGet, getRomApiRomsIdGet } from "@clients/romm";
import { config, db, emulatorsDb, jar } from "../app";
import unzip from 'unzip-stream';
import { Readable, Transform } from "node:stream";
import { createWriteStream } from "node:fs";
interface JobConfig
{
@ -22,13 +19,17 @@ interface JobConfig
export class InstallJob implements IJob
{
public id: number;
public source: string;
public sourceId: number;
public config?: JobConfig;
constructor(id: number, config?: JobConfig)
constructor(id: number, source: string, sourceId: number, config?: JobConfig)
{
this.id = id;
this.config = config;
this.sourceId = sourceId;
this.source = source;
}
public async start (cx: JobContext)

20
src/bun/api/notifications.ts
View file

@ -3,16 +3,33 @@ import { events } from './app';
export default function buildNotificationsStream ()
{
let closed = false;
let cleanup: (() => void) | undefined = undefined;
return new ReadableStream({
async start (controller)
{
const encoder = new TextEncoder();
function enqueue (data: Notification, event?: 'notification')
{
const evntString = event ? `event: ${event}\n` : '';
controller.enqueue(`${evntString}data: ${JSON.stringify(data)}\n\n`);
controller.enqueue(encoder.encode(`${evntString}data: ${JSON.stringify(data)}\n\n`));
}
// seems to help with issue of buffers not flushing, keeping the connection open forcefully
const keepAlive = setInterval(() =>
{
if (closed) return clearInterval(keepAlive);
try
{
controller.enqueue(encoder.encode(`: ping\n\n`));
} catch
{
closed = true;
clearInterval(keepAlive);
}
}, 15000);
const notificationHandler = (notification: Notification) =>
{
enqueue(notification, 'notification');
@ -23,6 +40,7 @@ export default function buildNotificationsStream ()
cancel: () =>
{
cleanup?.();
closed = true;
}
});
}

2
src/bun/api/rpc.ts
View file

@ -1,10 +1,10 @@
import { cors } from "@elysiajs/cors";
import Elysia from "elysia";
import { RPC_PORT } from "../../shared/constants";
import { host } from "../utils";
import clients from "./clients";
import { settings } from "./settings";
import { system } from "./system";
import { host } from "../utils/host";
const api = new Elysia({ serve: {} })
.use([cors(), clients, settings, system]);

5
src/bun/api/secrets.ts
View file

@ -118,7 +118,6 @@ class FallbackSecrets implements ISecrets
}
}
/*
try
{
await Bun.secrets.get({ service: 'test', name: 'test' });
@ -126,8 +125,6 @@ try
} catch
{
secrets = new FallbackSecrets();
}*/
secrets = new FallbackSecrets();
}
export default secrets;

47
src/bun/api/settings.ts
View file

@ -1,12 +1,15 @@
import z from "zod";
import { SettingsSchema } from "@shared/constants";
import Elysia from "elysia";
import { config, customEmulators, db, emulatorsDb } from "./app";
import Elysia, { status } from "elysia";
import { config, customEmulators, db, emulatorsDb, taskQueue } from "./app";
import * as appSchema from './schema/app';
import { findExec } from "./games/services/launchGameService";
import * as emulatorSchema from "./schema/emulators";
import { eq, inArray } from 'drizzle-orm';
import fs from 'node:fs/promises';
import { existsSync } from "node:fs";
import { InstallJob } from "./jobs/install-job";
import { move } from "fs-extra";
export const settings = new Elysia({ prefix: '/api/settings' })
.get('/emulators/automatic', async () =>
@ -90,6 +93,46 @@ export const settings = new Elysia({ prefix: '/api/settings' })
}, {
response: z.array(z.string())
})
.put('/path/download', async ({ body: { manualPath, drive } }) =>
{
if (taskQueue.hasActiveOfType(InstallJob))
{
return status("Forbidden", "Installation in progress");
}
const oldDownloadPath = config.get('downloadPath');
if (!existsSync(oldDownloadPath))
{
return status("Not Found", "Old downlod path doesn't exist");
}
async function isDirEmpty (dirname: string)
{
const files = await fs.readdir(dirname);
return files.length === 0;
}
const path = manualPath ?? drive;
if (!path)
{
return;
}
if (existsSync(path) && !isDirEmpty(path))
{
return status("Conflict", "New location alaready exists and is not empty");
}
await move(oldDownloadPath, path);
config.set('downloadPath', manualPath);
return manualPath;
}, {
body: z.object({
manualPath: z.string().optional(),
drive: z.string().optional()
})
})
.get("/:id", async ({ params: { id } }) =>
{
const value = config.get(id);

129
src/bun/api/system.ts
View file

@ -3,24 +3,38 @@ import open from 'open';
import z from "zod";
import os from 'node:os';
import { config, events } from "./app";
import { isSteamDeckGameMode } from "../utils";
import { isSteamDeck, openExternal } from "../utils";
import fs from 'node:fs/promises';
import buildNotificationsStream from "./notifications";
import path, { dirname } from "node:path";
import { DirSchema, DownloadsDrive } from "@/shared/constants";
import { getDevices, getDevicesCurated } from "./drives";
import getFolderSize from "get-folder-size";
import si from 'systeminformation';
// steam://open/keyboard?XPosition=%i&YPosition=%i&Width=%i&Height=%i&Mode=%d
export const system = new Elysia({ prefix: '/api/system' })
.post('/show_keyboard', async () =>
.post('/show_keyboard', async ({ body: { XPosition, YPosition, Width, Height } }) =>
{
if (isSteamDeckGameMode())
if (await isSteamDeck())
{
open('steam://open/keyboard');
const url = new URL('steam://open/keyboard');
if (XPosition) url.searchParams.set('XPosition', String(XPosition));
if (YPosition) url.searchParams.set('YPosition', String(YPosition));
if (Width) url.searchParams.set('Width', String(Width));
if (Height) url.searchParams.set('Height', String(Height));
open(url.href);
}
}, {
body: z.object({
XPosition: z.coerce.number().optional(),
YPosition: z.coerce.number().optional(),
Width: z.coerce.number().optional(),
Height: z.coerce.number().optional()
})
})
.get('/info', async () =>
{
const downloadStats = await fs.statfs(config.get('downloadPath'));
return {
homeDir: os.homedir(),
user: os.userInfo().username,
@ -29,9 +43,6 @@ export const system = new Elysia({ prefix: '/api/system' })
hostname: os.hostname(),
steamDeck: process.env.SteamDeck,
machine: os.machine(),
freeSpace: downloadStats.bsize * downloadStats.bavail,
totalSpace: downloadStats.bsize * downloadStats.blocks,
downloadsType: downloadStats.type
};
})
.get('/notifications', ({ set }) =>
@ -41,13 +52,105 @@ export const system = new Elysia({ prefix: '/api/system' })
set.headers['connection'] = 'keep-alive';
return new Response(buildNotificationsStream());
})
.get('/info/battery', async () =>
{
return si.battery();
})
.get('/info/wifi', async () =>
{
return si.wifiConnections();
})
.get('/info/bluetooth', async () =>
{
return si.bluetoothDevices();
})
.get('/drives', async () =>
{
const drives = await getDevices();
return drives;
})
.get('/drives/download', async () =>
{
const drives = await getDevicesCurated();
const downloadsPath = config.get('downloadPath');
const currentDownloadsSize = await getFolderSize(downloadsPath);
let used = false;
const drivesDownload: DownloadsDrive[] = drives
.filter(d => !!d.mountPoint)
.map(d => ({ ...d, depth: d.mountPoint!.split(path.sep).length }))
.sort((a, b) => b.depth - a.depth)
.map(d =>
{
const drive: DownloadsDrive = {
device: d.device,
label: d.label,
mountPoint: path.join(d.mountPoint!, 'gameflow'),
isRemovable: d.isRemovable,
size: d.size,
used: d.used,
isCurrentlyUsed: false,
unusableReason: null
};
if (!used && d.mountPoint && downloadsPath.startsWith(d.mountPoint))
{
drive.isCurrentlyUsed = true;
used = true;
}
if (!drive.isCurrentlyUsed && currentDownloadsSize && drive.size - drive.used <= currentDownloadsSize.size)
{
drive.unusableReason = 'not_enough_space';
}
else if (drive.isCurrentlyUsed && downloadsPath === drive.mountPoint)
{
drive.unusableReason = 'already_used';
}
return drive;
});
return {
downloadsSize: currentDownloadsSize.size,
configPath: dirname(config.path),
drives: drivesDownload,
};
})
.put('/dirs', async ({ body: { dirname, name } }) =>
{
await fs.mkdir(path.join(dirname, name));
}, {
body: z.object({ dirname: z.string(), name: z.string() })
})
.get('/dirs', async ({ query: { path: startingPath } }) =>
{
const currentPath = startingPath ?? dirname(Bun.main);
const paths = await fs.readdir(currentPath, { withFileTypes: true });
return {
name: path.basename(currentPath),
parentPath: path.dirname(currentPath),
dirs: paths.sort((a, b) => (b.isDirectory() ? 1 : 0) - (a.isDirectory() ? 1 : 0)).map(p =>
({
name: p.name,
parentPath: p.parentPath,
isDirectory: p.isDirectory()
}))
};
},
{
query: z.object({ path: z.string().optional() }),
response: z.object({
name: z.string(),
parentPath: z.string(),
dirs: z.array(DirSchema)
})
})
.post('/exit', () =>
{
events.emit('exitapp');
})
.post('/open', async ({ query: { url } }) =>
.post('/open', async ({ body: { url } }) =>
{
open(url);
await openExternal(url);
}, {
query: z.object({ url: z.url() })
body: z.object({ url: z.string() })
});

12
src/bun/api/task-queue.ts
View file

@ -46,6 +46,18 @@ export class TaskQueue
return this.activeQueue.length > 0;
}
public hasActiveOfType (type: any)
{
for (const entry of this.activeQueue)
{
if (entry.context.job instanceof type)
{
return true;
}
}
return false;
}
public waitForJob (id: string): Promise<void>
{
const job = this.queue?.find(j => j.context.id === id) ?? this.activeQueue?.find(j => j.context.id === id);

5
src/bun/browser.ts
View file

@ -2,6 +2,8 @@ import { killBrowser, spawnBrowser } from './utils/browser-spawner';
import { BuildParams } from './utils/browser-params';
import os from 'node:os';
import { EventEmitter } from 'node:stream';
import { config } from './api/app';
import { dirname } from 'node:path';
export default async function init (events: EventEmitter, forceBrowser: boolean)
{
@ -51,7 +53,7 @@ async function runWebview (events: EventEmitter)
async function runBrowser (events: EventEmitter)
{
const browserParams = await BuildParams();
const browserParams = await BuildParams({ configPath: dirname(config.path) });
if (!browserParams)
{
console.error("Could not find valid browser");
@ -68,6 +70,7 @@ async function runBrowser (events: EventEmitter)
detached: false,
execPath: browserParams.browser.path,
source: browserParams.browser.source,
configPath: dirname(config.path),
ipc (message)
{
console.log(message);

2
src/bun/server.ts
View file

@ -1,7 +1,7 @@
import { SERVER_PORT } from "../shared/constants";
import path from 'node:path';
import { host } from "./utils";
import appInfo from '../../package.json';
import { host } from "./utils/host";
export function RunBunServer ()
{

4
src/bun/types/types.d.ts vendored
View file

@ -1,7 +1,9 @@
import { ChildProcess } from "node:child_process";
declare const IS_BINARY: string;
export type ActiveGame = {
pid?: number;
process?: ChildProcess;
gameId: number;
name: string;
command: string;

42
src/bun/utils.ts
View file

@ -1,11 +1,5 @@
import { networkInterfaces } from 'node:os';
const localIp = Object.values(networkInterfaces())
.flat()
.find((iface) => iface?.family === 'IPv4' && !iface.internal)?.address || 'localhost';
export const host = process.env.PUBLIC_ACCESS ? localIp : 'localhost';
import { $ } from 'bun';
export function checkRunning (pid: number)
{
@ -27,4 +21,38 @@ export function getErrorMessage (error: unknown): string
export function isSteamDeckGameMode ()
{
return !!Bun.env.SteamDeck;
}
export async function isSteamDeck ()
{
if (process.platform === 'linux')
{
try
{
const productName = await Bun.file("/sys/class/dmi/id/product_name").text();
const isSteamDeck = ["Jupiter", "Galileo"].includes(productName.trim());
return isSteamDeck;
} catch (error)
{
return isSteamDeckGameMode();
}
}
}
export async function openExternal (target: string)
{
if (process.platform === "linux")
{
return $`xdg-open ${target}`.throws(true);
}
if (process.platform === "win32")
{
return $`cmd /c start ${target}`.throws(true);
}
if (process.platform === "darwin")
{
return $`open ${target}`.throws(true);
}
}

14
src/bun/utils/browser-params.ts
View file

@ -1,11 +1,13 @@
import { SERVER_URL } from "../../shared/constants";
import os from 'node:os';
import path, { dirname } from 'node:path';
import path from 'node:path';
import { getBrowserPath } from "./get-browser";
import { host, isSteamDeckGameMode } from "../utils";
import { isSteamDeckGameMode } from "../utils";
import { config } from "../api/app";
import { ensureDir } from 'fs-extra';
import { host } from "./host";
export async function BuildParams ()
export async function BuildParams (data: { configPath: string; })
{
const validBrowser = await getBrowserPath({
browserOrder: ['chrome', 'chromium']
@ -28,15 +30,19 @@ export async function BuildParams ()
const isEdge = validBrowser.path.toLowerCase().includes('edge') || validBrowser.path.toLowerCase().includes('msedge');
console.log(`[Browser] Detected: ${validBrowser.type} from ${validBrowser.source} - ${isEdge ? 'Edge' : 'Chrome/Chromium'}`);
const dataPath = path.join(data.configPath, 'browser-data');
await ensureDir(dataPath);
args.push(`--app=${SERVER_URL(host)}`);
args.push(`--app-id=gameflow`);
args.push(`--force-app-mode`);
args.push('--no-default-browser-check');
args.push('--new-instance');
args.push('--no-first-run');
args.push('--disable-infobars');
args.push("--disable-extensions");
args.push("--disable-plugins");
args.push(`--user-data-dir=${path.join(dirname(config.path), 'browser-data')}`);
args.push(`--user-data-dir=${dataPath}`);
args.push('--disable-sync'); //Disable syncing to a Google account
args.push('--disable-sync-preferences');
args.push('--disable-component-update');

8
src/bun/utils/browser-spawner.ts
View file

@ -1,7 +1,4 @@
import { $, type Subprocess } from "bun";
import path from 'node:path';
import { readFile } from 'node:fs/promises';
import { existsSync } from 'node:fs';
import os from 'node:os';
export type RunBrowserType = "chrome" | "chromium" | "firefox" | "edge";
@ -25,6 +22,7 @@ interface SpawnBrowserOptions
detached?: boolean;
execPath: string; // Required: browser executable path from get-browser.ts
source: RunBrowserSource; // How the browser was discovered (running, system, or flatpak)
configPath: string;
onExit?: () => void; // Called when the browser exists duh
ipc?: (message: string) => void;
}
@ -69,7 +67,8 @@ export async function spawnBrowser ({
execPath,
source,
onExit,
ipc
ipc,
configPath
}: SpawnBrowserOptions): Promise<Subprocess>
{
// Configuration for both Flatpak and Native
@ -117,6 +116,7 @@ export async function spawnBrowser ({
"--branch=stable",
`--arch=${process.arch === "x64" ? "x86_64" : process.arch}`, // map node arch to flatpak arch
`--command=${target.internalCmd}`,
`--filesystem=${configPath}`, // we must allw it to use our own config path to save profile data
"--file-forwarding",
...envFlags // Inject env vars here
];

7
src/bun/utils/host.ts Normal file
View file

@ -0,0 +1,7 @@
import { networkInterfaces } from "node:os";
const localIp = Object.values(networkInterfaces())
.flat()
.find((iface) => iface?.family === 'IPv4' && !iface.internal)?.address || 'localhost';
export const host = process.env.PUBLIC_ACCESS ? localIp : 'localhost';

2
src/bun/webview/base.ts
View file

@ -1,6 +1,6 @@
import { SERVER_URL } from "@/shared/constants";
import Webview from "@rcompat/webview";
import { host } from "../utils";
import { host } from "../utils/host";
export default function (webview: Webview)
{