앱 v1.2.0: exe 디스코드 로그인 · 유저 등록 · 관리자 페이지
- 사이트 서버: 앱 로그인(/auth/app/begin·start·poll, 기존 OAuth 콜백 재사용), 앱 토큰(/app/me, 해시 저장), 유저 등록 API(/app/admin/users, 등록·역할·해제는 최고 관리자만, 목록은 관리자도). 최고 관리자 2명 고정 - 앱: 등록된 계정으로 로그인해야 코어(봇·녹음·사이트 연결)를 띄운다. 미등록이면 "등록되지 않은 아이디" + 아이디 표시. 10분마다 재확인, 등록 해제 시 즉시 잠금. 서버 연결 실패 시 마지막 확인 후 3일 유예 - 겜녹이 봇 토큰을 exe 에 넣지 않고 로그인한 등록 유저에게 서버가 내려준다 (잠기면 삭제). win-ci 토큰 주입 제거 - 관리자 탭(유저 등록·목록·접속 기록), 관리자 전용 설정(봇 변경·TTS 안내·보관 기간·사이트·학습 데이터·파인튜닝)은 일반 유저에게 잠금 표시 + 메인 프로세스에서 차단 - 테스트: 서버 앱 로그인 2건, 앱↔서버 통합 3건, Electron 로그인 E2E 스크립트(scripts/login-e2e.mts) Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
18
README.md
18
README.md
@@ -9,12 +9,20 @@
|
||||
- **제작 완료 보고서 (M0~M8)**: [`docs/gemnoki-final-report.pdf`](docs/gemnoki-final-report.pdf) · 단계별 테스트 기록: [`docs/dev/test-results.md`](docs/dev/test-results.md)
|
||||
- Windows 실행 파일: Gitea 릴리스 [v1.0.0](https://git.tkrmagid.kr/tkrmagid/game_voice_recorder/releases/tag/v1.0.0) (`GameVoiceRecorder-1.0.0-win-x64.zip` 권장, 단일 파일 `GameVoiceRecorder-1.0.0-portable.exe`)
|
||||
|
||||
## 디스코드 봇 (v1.1.0~)
|
||||
## 로그인 · 관리자 (v1.2.0~)
|
||||
|
||||
- 기본은 **겜녹이 봇으로 진행**: exe 안에 겜녹이 봇 토큰이 들어 있어 첫 실행 마법사에서 토큰을 넣지 않아도 바로 연결된다.
|
||||
- **다른 봇으로 진행하기**를 고르면 직접 만든 봇 토큰을 넣는다 (암호화 저장). 설정 창 디스코드 탭에서 언제든 두 방식을 바꿀 수 있고, 넣어 둔 토큰은 바꿔도 지워지지 않는다. v1.0.0 에서 토큰을 넣어 쓰던 설치는 다른 봇 모드로 그대로 이어진다.
|
||||
- 토큰은 저장소에 없다. 빌드할 때 `GVR_BUILTIN_BOT_TOKEN` 환경변수에서 읽어 감춘 값으로 박는다 (`app/build.mjs`, win-ci 는 `tools/win-ci/run.sh full` 이 서버 비밀 저장소에서 넣는다). 환경변수 없이 빌드하면 기본 봇이 없는 빌드가 된다.
|
||||
- 감춘 것일 뿐 암호화가 아니다. exe 를 풀면 토큰을 꺼낼 수 있으니 **기본 봇이 든 exe 는 공개 릴리스에 올리지 않는다.**
|
||||
- exe 는 **등록된 디스코드 계정으로 로그인**해야 열린다. 로그인 버튼 → 브라우저에서 디스코드 로그인 → 사이트 서버(gvr.tkrmagid.kr)가 등록 명단을 확인한다. 등록되지 않은 아이디면 "등록되지 않은 아이디입니다"와 디스코드 아이디를 보여 주고 앱을 열지 않는다.
|
||||
- 역할: **최고 관리자**(`293719842274541579`, `1352267557213573160`, 서버에 고정) · **관리자** · **유저**. 유저 등록 · 역할 변경 · 등록 해제는 최고 관리자만, 등록 명단 보기와 관리자 전용 설정은 관리자도 할 수 있다.
|
||||
- 설정 창 **🛡️ 관리자** 탭(관리자에게만 보임): 유저 등록(디스코드 아이디 + 역할), 등록 계정 목록(역할 · 마지막 접속 · 앱 버전 · 등록한 사람), 관리자 전용 기능 목록.
|
||||
- 관리자 전용 (일반 유저 화면에서는 🔒 잠김, 메인 프로세스에서도 막음): 다른 봇으로 바꾸기 · 봇 토큰, 녹음 안내(TTS) 끄기 · 문구, 음성 보관 기간, 사이트 서버 주소 · PC 이름 · 등록/해제, 학습 데이터 삭제, 파인튜닝.
|
||||
- 앱은 시작할 때와 10분마다 등록 여부를 다시 확인한다. 등록이 해제되면 바로 잠그고 봇 · 녹음 · 사이트 연결을 멈춘다. 사이트 서버에 못 붙으면 마지막 확인 뒤 3일까지는 그대로 쓴다.
|
||||
- 서버 쪽: `site/server/src/app-auth.ts` (`/auth/app/*`, `/app/me`, `/app/admin/users`), 앱 쪽: `app/src/core/auth.ts`, 권한 목록: `app/src/core/roles.ts`. 로그인 E2E: `app/scripts/login-e2e.mts`.
|
||||
|
||||
## 디스코드 봇
|
||||
|
||||
- 기본은 **겜녹이 봇으로 진행**: 로그인하면 사이트 서버가 겜녹이 봇 토큰을 내려주므로(암호화 저장) 토큰을 넣지 않아도 바로 연결된다.
|
||||
- **다른 봇으로 진행하기**(관리자만)를 고르면 직접 만든 봇 토큰을 넣는다 (암호화 저장). v1.0.0 에서 토큰을 넣어 쓰던 설치는 다른 봇 모드로 그대로 이어진다.
|
||||
- v1.2.0 부터 **exe 안에 봇 토큰이 없다** (v1.1.0 은 빌드 때 감춰 넣었다). 등록되지 않은 사람은 exe 를 받아도 겜녹이 봇을 쓸 수 없고, 등록이 해제되면 받아 둔 토큰도 지운다. 빌드에 비밀값이 필요 없어 공개 릴리스에 올려도 된다.
|
||||
|
||||
## 진행 현황
|
||||
|
||||
|
||||
@@ -10,15 +10,8 @@ fs.writeFileSync(
|
||||
'// 자동 생성: schema.sql 사본 (npm run build 가 다시 만든다)\nexport const SCHEMA_SQL = ' + JSON.stringify(fs.readFileSync(path.join(root, 'src/core/db/schema.sql'), 'utf8')) + ';\n',
|
||||
);
|
||||
fs.rmSync(path.join(root, 'dist'), { recursive: true, force: true });
|
||||
// 겜녹이 기본 봇 토큰: 환경변수에서만 받아 감춘 값으로 박는다 (저장소·로그에 남기지 않는다)
|
||||
let builtinBot = '';
|
||||
if (process.env.GVR_BUILTIN_BOT_TOKEN) {
|
||||
const mod = await build({ entryPoints: [path.join(root, 'src/core/builtin-bot.ts')], bundle: true, platform: 'node', format: 'esm', write: false, logLevel: 'silent' });
|
||||
const { encodeBuiltinToken } = await import('data:text/javascript;base64,' + Buffer.from(mod.outputFiles[0].text).toString('base64'));
|
||||
builtinBot = encodeBuiltinToken(process.env.GVR_BUILTIN_BOT_TOKEN.trim());
|
||||
}
|
||||
console.log(`겜녹이 기본 봇 토큰: ${builtinBot ? '포함' : '없음 (GVR_BUILTIN_BOT_TOKEN 미설정)'}`);
|
||||
const common = { bundle: true, platform: 'node', target: 'node22', format: 'cjs', sourcemap: true, alias: { '@gvr/shared': shared }, define: { __GVR_BUILTIN_BOT__: JSON.stringify(builtinBot) }, logLevel: 'info' };
|
||||
// 겜녹이 기본 봇 토큰은 exe 에 넣지 않는다. 로그인한 등록 유저에게 사이트 서버가 내려준다 (src/core/auth.ts)
|
||||
const common = { bundle: true, platform: 'node', target: 'node22', format: 'cjs', sourcemap: true, alias: { '@gvr/shared': shared }, logLevel: 'info' };
|
||||
await build({ ...common, entryPoints: ['src/main/main.ts'], outfile: 'dist/main.cjs', packages: 'external', external: ['electron'] });
|
||||
await build({ ...common, entryPoints: ['src/main/preload.ts'], outfile: 'dist/preload.cjs', external: ['electron'] });
|
||||
await build({ ...common, entryPoints: ['src/core/cli.ts'], outfile: 'dist/cli.cjs', packages: 'external' });
|
||||
|
||||
4
app/package-lock.json
generated
4
app/package-lock.json
generated
@@ -1,12 +1,12 @@
|
||||
{
|
||||
"name": "gvr-app",
|
||||
"version": "1.1.0",
|
||||
"version": "1.2.0",
|
||||
"lockfileVersion": 3,
|
||||
"requires": true,
|
||||
"packages": {
|
||||
"": {
|
||||
"name": "gvr-app",
|
||||
"version": "1.1.0",
|
||||
"version": "1.2.0",
|
||||
"license": "UNLICENSED",
|
||||
"dependencies": {
|
||||
"@discordjs/voice": "^0.19.2",
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
{
|
||||
"name": "gvr-app",
|
||||
"productName": "겜녹이",
|
||||
"version": "1.1.0",
|
||||
"version": "1.2.0",
|
||||
"description": "겜녹이 (Game Voice Recorder) - 게임 연동 디스코드 음성 기록",
|
||||
"private": true,
|
||||
"main": "dist/main.cjs",
|
||||
|
||||
206
app/scripts/login-e2e.mts
Normal file
206
app/scripts/login-e2e.mts
Normal file
@@ -0,0 +1,206 @@
|
||||
// 로그인 E2E (리눅스 · Xvfb): 실제 Electron 앱 + 이 저장소의 사이트 서버 코드 + 가짜 디스코드 OAuth.
|
||||
// 겜녹이 봇 토큰은 서버에서만 받으므로, 로그인 후 봇이 실제로 디스코드에 붙는지까지 본다.
|
||||
// GVR_E2E_BOT_TOKEN=<겜녹이 봇 토큰> node --import tsx scripts/login-e2e.mts [스크린샷 폴더]
|
||||
// (먼저 npm run build)
|
||||
import { spawn } from 'node:child_process';
|
||||
import fs from 'node:fs';
|
||||
import http from 'node:http';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import WebSocket from 'ws';
|
||||
import { buildServer } from '../../site/server/src/app.ts';
|
||||
import { AppAuth } from '../src/core/auth.ts';
|
||||
import { SettingsStore } from '../src/core/settings.ts';
|
||||
|
||||
const BOT = process.env.GVR_E2E_BOT_TOKEN;
|
||||
if (!BOT) throw new Error('GVR_E2E_BOT_TOKEN 이 필요합니다');
|
||||
const shots = process.argv[2];
|
||||
const SUPER = '293719842274541579';
|
||||
const FRIEND = '111111111111111111';
|
||||
const PORT = 18931;
|
||||
const base = `http://127.0.0.1:${PORT}`;
|
||||
const work = fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-login-e2e-'));
|
||||
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
|
||||
const results: [string, boolean, string][] = [];
|
||||
const check = (name: string, ok: boolean, detail = '') => {
|
||||
results.push([name, ok, detail]);
|
||||
console.log(`${ok ? '✔' : '✘'} ${name}${detail ? ` · ${detail}` : ''}`);
|
||||
};
|
||||
|
||||
// ---- 가짜 디스코드: OAuth code = 로그인할 아이디, 봇 토큰으로 /users/:id 조회
|
||||
const names: Record<string, string> = { [SUPER]: '사금향', [FRIEND]: '테스트친구' };
|
||||
const dc = http.createServer((req, res) => {
|
||||
const u = new URL(req.url!, 'http://x');
|
||||
res.setHeader('content-type', 'application/json');
|
||||
if (u.pathname === '/oauth2/token') {
|
||||
let b = '';
|
||||
req.on('data', (c) => (b += c));
|
||||
req.on('end', () => res.end(JSON.stringify({ access_token: new URLSearchParams(b).get('code') })));
|
||||
return;
|
||||
}
|
||||
if (u.pathname === '/users/@me') {
|
||||
const id = String(req.headers.authorization).replace('Bearer ', '');
|
||||
return res.end(JSON.stringify({ id, username: names[id] ?? 'x', global_name: names[id] ?? null, avatar: null }));
|
||||
}
|
||||
const m = /^\/users\/(\d+)$/.exec(u.pathname);
|
||||
if (m && names[m[1]!]) return res.end(JSON.stringify({ id: m[1], username: names[m[1]!], global_name: names[m[1]!], avatar: null }));
|
||||
res.statusCode = 404;
|
||||
res.end('{}');
|
||||
});
|
||||
await new Promise<void>((r) => dc.listen(0, '127.0.0.1', () => r()));
|
||||
const dcUrl = `http://127.0.0.1:${(dc.address() as any).port}`;
|
||||
|
||||
const { app: site } = await buildServer({
|
||||
port: PORT, host: '127.0.0.1', publicUrl: base, clientId: 'cid', clientSecret: 's', botToken: BOT,
|
||||
allowedGuilds: [], owners: [SUPER], superAdmins: [SUPER], sessionSecret: 'x'.repeat(32), dataDir: path.join(work, 'site'),
|
||||
webDir: '/nonexistent', version: 'e2e', discordApi: dcUrl, assetUpstream: {},
|
||||
});
|
||||
site.log.level = 'warn';
|
||||
await site.listen({ host: '127.0.0.1', port: PORT });
|
||||
|
||||
// 브라우저 흉내: PATH 맨 앞에 가짜 xdg-open 을 둔다 (Electron shell.openExternal 이 부른다. 실제 브라우저는 열지 않는다)
|
||||
// 로그인 주소 → 가짜 디스코드 → 콜백. 로그인할 아이디는 파일에서
|
||||
const loginAs = path.join(work, 'login-as');
|
||||
const binDir = path.join(work, 'bin');
|
||||
fs.mkdirSync(binDir);
|
||||
const browserSh = path.join(binDir, 'xdg-open');
|
||||
fs.writeFileSync(
|
||||
browserSh,
|
||||
`#!/bin/sh\nJAR=$(mktemp)\nLOC=$(curl -s -c "$JAR" -o /dev/null -w '%{redirect_url}' "$1")\nSTATE=$(printf '%s' "$LOC" | sed -n 's/.*[?&]state=\\([^&]*\\).*/\\1/p')\ncurl -s -b "$JAR" -o /dev/null "${base}/auth/discord/callback?code=$(cat ${loginAs})&state=$STATE"\nrm -f "$JAR"\n`,
|
||||
{ mode: 0o755 },
|
||||
);
|
||||
const browse = (who: string) => async (url: string) => {
|
||||
const start = await fetch(url, { redirect: 'manual' });
|
||||
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
|
||||
await fetch(`${base}/auth/discord/callback?code=${who}&state=${encodeURIComponent(state)}`, { headers: { cookie: start.headers.getSetCookie()[0]!.split(';')[0]! }, redirect: 'manual' });
|
||||
};
|
||||
|
||||
// 최고 관리자 (관리자 화면 API 를 대신 부른다)
|
||||
const adminSt = new SettingsStore(path.join(work, 'admin'));
|
||||
adminSt.update({ site: { serverUrl: base } });
|
||||
const admin = new AppAuth(adminSt, { version: 'e2e', openUrl: browse(SUPER), pollMs: 100 });
|
||||
check('최고 관리자 로그인', (await admin.login()).role === 'superadmin');
|
||||
await admin.adminAddUser(FRIEND, 'user');
|
||||
check('최고 관리자가 친구를 유저로 등록', (await admin.adminUsers()).users.some((u) => u.id === FRIEND && u.role === 'user'));
|
||||
|
||||
// ---- Electron 앱
|
||||
const data = path.join(work, 'app');
|
||||
fs.mkdirSync(data);
|
||||
fs.writeFileSync(path.join(data, 'settings.json'), JSON.stringify({ firstRunDone: true, site: { serverUrl: base }, games: { valorant: false, lol: false } }));
|
||||
fs.writeFileSync(loginAs, FRIEND);
|
||||
const electron = path.join(import.meta.dirname, '..', 'node_modules', '.bin', 'electron');
|
||||
const proc = spawn('xvfb-run', ['-a', electron, '.', `--data-dir=${data}`, '--remote-debugging-port=9333', '--no-sandbox'], {
|
||||
cwd: path.join(import.meta.dirname, '..'),
|
||||
env: { ...process.env, PATH: `${binDir}:${process.env.PATH}`, WAYLAND_DISPLAY: '', XDG_SESSION_TYPE: 'x11', GVR_BOT_TOKEN: '', ELECTRON_ENABLE_LOGGING: '1' },
|
||||
stdio: ['ignore', 'pipe', 'pipe'],
|
||||
detached: true, // 끝날 때 xvfb-run · Electron 을 프로세스 그룹째 끈다
|
||||
});
|
||||
const logs: string[] = [];
|
||||
proc.stdout.on('data', (b) => logs.push(...String(b).split('\n')));
|
||||
proc.stderr.on('data', (b) => logs.push(...String(b).split('\n')));
|
||||
|
||||
// CDP: 설정 창에서 window.gvr 호출
|
||||
let ws: WebSocket | null = null;
|
||||
for (let i = 0; i < 60 && !ws; i++) {
|
||||
await sleep(1000);
|
||||
try {
|
||||
const t = ((await (await fetch('http://127.0.0.1:9333/json')).json()) as any[]).find((x) => x.type === 'page');
|
||||
if (t) {
|
||||
ws = new WebSocket(t.webSocketDebuggerUrl);
|
||||
await new Promise((r) => ws!.once('open', r));
|
||||
}
|
||||
} catch {
|
||||
/* 아직 */
|
||||
}
|
||||
}
|
||||
if (!ws) throw new Error('Electron 창에 붙지 못했습니다\n' + logs.join('\n'));
|
||||
let seq = 0;
|
||||
const cdp = (method: string, params: any = {}) =>
|
||||
new Promise<any>((res) => {
|
||||
const id = ++seq;
|
||||
const on = (m: WebSocket.RawData) => {
|
||||
const j = JSON.parse(String(m));
|
||||
if (j.id === id) {
|
||||
ws!.off('message', on);
|
||||
res(j.result);
|
||||
}
|
||||
};
|
||||
ws!.on('message', on);
|
||||
ws!.send(JSON.stringify({ id, method, params }));
|
||||
});
|
||||
const gvr = async (expr: string): Promise<{ ok: boolean; v?: any; err?: string }> => {
|
||||
const r = await cdp('Runtime.evaluate', { expression: `(async () => JSON.stringify(await (${expr})))()`, awaitPromise: true });
|
||||
if (r.exceptionDetails) return { ok: false, err: r.exceptionDetails.exception?.description ?? r.exceptionDetails.text };
|
||||
return { ok: true, v: r.result.value === undefined ? undefined : JSON.parse(r.result.value) };
|
||||
};
|
||||
const shot = async (name: string) => {
|
||||
if (!shots) return;
|
||||
await sleep(700);
|
||||
const r = await cdp('Page.captureScreenshot', { format: 'png' });
|
||||
fs.mkdirSync(shots, { recursive: true });
|
||||
fs.writeFileSync(path.join(shots, `${name}.png`), Buffer.from(r.data, 'base64'));
|
||||
};
|
||||
|
||||
try {
|
||||
await sleep(1500);
|
||||
let a = (await gvr('window.gvr.authState()')).v;
|
||||
check('새 설치: 로그인 화면', a.status === 'signed_out' && !a.appReady, a.status);
|
||||
check('로그인 전: 코어 요청 막힘', /로그인이 필요합니다/.test((await gvr('window.gvr.getState()')).err ?? ''));
|
||||
await shot('electron-login');
|
||||
|
||||
// 로그인 (브라우저 → 가짜 디스코드 → 콜백 → 앱이 결과를 받아 감)
|
||||
void gvr('window.gvr.authLogin()');
|
||||
for (let i = 0; i < 60 && !(a?.status === 'ok' && a.appReady); i++) {
|
||||
await sleep(500);
|
||||
a = (await gvr('window.gvr.authState()')).v;
|
||||
}
|
||||
check('등록된 친구 로그인 → 앱 열림', a.status === 'ok' && a.appReady && a.role === 'user', `${a.status} ${a.role}`);
|
||||
let st: any = null;
|
||||
for (let i = 0; i < 90; i++) {
|
||||
st = (await gvr('window.gvr.getState()')).v;
|
||||
if (st?.bot.status === 'ready' || st?.bot.status === 'error') break;
|
||||
await sleep(500);
|
||||
}
|
||||
check('서버에서 받은 겜녹이 봇 토큰으로 봇 로그인', st?.bot.status === 'ready' && st.builtinBot, `${st?.bot.status} ${st?.bot.user?.name ?? ''} 서버 ${st?.bot.guilds.length ?? 0}곳 ${st?.bot.error ?? ''}`);
|
||||
check('계정 표시', st?.account.user?.id === FRIEND && st.account.role === 'user');
|
||||
|
||||
// 일반 유저 권한
|
||||
const r1 = await gvr(`window.gvr.updateSettings({ discord: { botMode: 'custom' } })`);
|
||||
check('유저: 다른 봇으로 바꾸기 거절', !r1.ok && /관리자만/.test(r1.err ?? ''));
|
||||
const r2 = await gvr(`window.gvr.updateSettings({ storage: { retentionDays: 30 } })`);
|
||||
check('유저: 보관 기간 변경 거절', !r2.ok && /관리자만/.test(r2.err ?? ''));
|
||||
const r3 = await gvr(`window.gvr.setSecret('botToken', 'x')`);
|
||||
check('유저: 봇 토큰 입력 거절', !r3.ok);
|
||||
const r4 = await gvr(`window.gvr.clearTrainingData()`);
|
||||
check('유저: 학습 데이터 삭제 거절', !r4.ok && /관리자만/.test(r4.err ?? ''));
|
||||
const r5 = await gvr(`window.gvr.updateSettings({ general: { sfx: false } })`);
|
||||
check('유저: 일반 설정은 바꿀 수 있음', r5.ok && r5.v.general.sfx === false);
|
||||
const r6 = await gvr(`window.gvr.adminAddUser('${SUPER}', 'user')`);
|
||||
check('유저: 유저 등록 API 거절 (서버)', !r6.ok && /최고 관리자만/.test(r6.err ?? ''));
|
||||
await gvr(`(location.hash = '#/settings/storage', 1)`);
|
||||
await shot('electron-user-storage');
|
||||
|
||||
// 등록 해제 → 다시 확인하면 잠김 · 봇 멈춤
|
||||
await admin.adminRemoveUser(FRIEND);
|
||||
a = (await gvr('window.gvr.authRecheck()')).v;
|
||||
check('등록 해제 후 확인 → 등록되지 않은 아이디로 잠김', a.status === 'not_registered' && !a.appReady, a.status);
|
||||
check('잠긴 뒤 코어 요청 막힘', /로그인이 필요합니다/.test((await gvr('window.gvr.getState()')).err ?? ''));
|
||||
const secrets = fs.existsSync(path.join(data, 'secrets.bin')) ? fs.readFileSync(path.join(data, 'secrets.bin')) : Buffer.alloc(0);
|
||||
check('잠긴 뒤 받아 둔 봇 토큰 삭제', !secrets.includes(Buffer.from(BOT)) && !secrets.toString('latin1').includes('builtinBotToken'));
|
||||
await shot('electron-not-registered');
|
||||
} finally {
|
||||
ws?.close();
|
||||
try {
|
||||
process.kill(-proc.pid!, 'SIGTERM');
|
||||
} catch {
|
||||
/* 이미 끝남 */
|
||||
}
|
||||
await sleep(1500);
|
||||
await site.close();
|
||||
dc.close();
|
||||
fs.writeFileSync(path.join(work, 'electron.log'), logs.join('\n'));
|
||||
console.log(`작업 폴더 ${work}`);
|
||||
}
|
||||
const failed = results.filter((r) => !r[1]);
|
||||
console.log(`\n${results.length - failed.length}/${results.length} 통과`);
|
||||
process.exit(failed.length ? 1 : 0);
|
||||
198
app/src/core/auth.ts
Normal file
198
app/src/core/auth.ts
Normal file
@@ -0,0 +1,198 @@
|
||||
// 앱(exe) 디스코드 로그인. 사이트 서버(site/server/src/app-auth.ts)가 유저 명단을 갖고 있다.
|
||||
// - 로그인: 서버에 요청을 만들고 브라우저로 디스코드 로그인 → 결과를 받아 온다 (토큰은 DPAPI 로 암호화 저장)
|
||||
// - 확인: 시작할 때와 10분마다 /app/me. 등록 해제 · 로그아웃되면 바로 잠그고 받아 둔 겜녹이 봇 토큰도 지운다
|
||||
// - 서버에 잠깐 못 붙으면 마지막 확인 후 3일까지는 그대로 쓴다
|
||||
import { EventEmitter } from 'node:events';
|
||||
import type { AppLoginBegin, AppLoginPoll, AppMe, AppRole, AppUserInfo, AppUserRow } from '@gvr/shared';
|
||||
import type { SettingsStore } from './settings.js';
|
||||
import { logger } from './util/log.js';
|
||||
|
||||
const log = logger('auth');
|
||||
|
||||
export type AuthStatus = 'checking' | 'signed_out' | 'waiting' | 'ok' | 'not_registered' | 'error';
|
||||
export interface AuthState {
|
||||
status: AuthStatus;
|
||||
user: AppUserInfo | null;
|
||||
role: AppRole | null;
|
||||
/** 서버에 못 붙어 마지막 확인 결과로 쓰는 중 */
|
||||
offline: boolean;
|
||||
error: string | null;
|
||||
/** 브라우저 로그인 대기 중이면 연 주소 (브라우저가 안 열렸을 때 다시 열기용) */
|
||||
loginUrl: string | null;
|
||||
verifiedAt: number | null;
|
||||
}
|
||||
|
||||
export interface AuthOptions {
|
||||
version: string;
|
||||
openUrl: (url: string) => void | Promise<void>;
|
||||
/** 서버에 못 붙을 때 마지막 확인으로 버티는 시간 (기본 3일) */
|
||||
offlineGraceMs?: number;
|
||||
pollMs?: number;
|
||||
}
|
||||
|
||||
class HttpError extends Error {
|
||||
constructor(
|
||||
public status: number,
|
||||
public body: any,
|
||||
) {
|
||||
super(body?.message || body?.error || `HTTP ${status}`);
|
||||
}
|
||||
}
|
||||
|
||||
export class AppAuth extends EventEmitter {
|
||||
state: AuthState = { status: 'checking', user: null, role: null, offline: false, error: null, loginUrl: null, verifiedAt: null };
|
||||
private loginSeq = 0;
|
||||
|
||||
constructor(
|
||||
private settings: SettingsStore,
|
||||
private opts: AuthOptions,
|
||||
) {
|
||||
super();
|
||||
}
|
||||
|
||||
get ok(): boolean {
|
||||
return this.state.status === 'ok';
|
||||
}
|
||||
private get server(): string {
|
||||
return this.settings.get().site.serverUrl.replace(/\/$/, '');
|
||||
}
|
||||
|
||||
private set(patch: Partial<AuthState>): void {
|
||||
this.state = { ...this.state, ...patch };
|
||||
this.emit('change', this.state);
|
||||
}
|
||||
|
||||
private async call<T>(method: string, path: string, body?: unknown, token = this.settings.getSecret('appToken')): Promise<T> {
|
||||
const r = await fetch(this.server + path, {
|
||||
method,
|
||||
headers: {
|
||||
...(body !== undefined ? { 'content-type': 'application/json' } : {}),
|
||||
...(token ? { authorization: `Bearer ${token}` } : {}),
|
||||
'x-gvr-version': this.opts.version,
|
||||
},
|
||||
body: body !== undefined ? JSON.stringify(body) : undefined,
|
||||
signal: AbortSignal.timeout(15000),
|
||||
});
|
||||
const text = await r.text();
|
||||
let json: any = null;
|
||||
try {
|
||||
json = text ? JSON.parse(text) : null;
|
||||
} catch {
|
||||
/* JSON 아님 */
|
||||
}
|
||||
if (!r.ok) throw new HttpError(r.status, json);
|
||||
return json as T;
|
||||
}
|
||||
|
||||
/** 로그인 정보 · 겜녹이 봇 토큰을 지운다 (등록 해제 · 로그아웃) */
|
||||
private forget(): void {
|
||||
for (const k of ['appToken', 'builtinBotToken', 'auth'] as const) if (this.settings.hasSecret(k)) this.settings.setSecret(k, null);
|
||||
}
|
||||
|
||||
/** 저장된 토큰으로 서버에 확인 */
|
||||
async check(): Promise<AuthState> {
|
||||
if (this.state.status === 'waiting') return this.state;
|
||||
const token = this.settings.getSecret('appToken');
|
||||
if (!token) {
|
||||
this.set({ status: 'signed_out', user: null, role: null, offline: false, error: null, verifiedAt: null });
|
||||
return this.state;
|
||||
}
|
||||
try {
|
||||
const me = await this.call<AppMe>('GET', '/app/me');
|
||||
const cache = { user: me.user, role: me.role, verifiedAt: Date.now() };
|
||||
this.settings.setSecret('auth', cache);
|
||||
if (me.botToken !== (this.settings.getSecret('builtinBotToken') ?? null)) this.settings.setSecret('builtinBotToken', me.botToken);
|
||||
this.set({ status: 'ok', user: me.user, role: me.role, offline: false, error: null, loginUrl: null, verifiedAt: cache.verifiedAt });
|
||||
} catch (e: any) {
|
||||
if (e instanceof HttpError && (e.status === 401 || e.status === 403)) {
|
||||
const notReg = e.status === 403 && e.body?.error === 'not_registered';
|
||||
log.warn(notReg ? '등록이 해제된 아이디라 잠급니다' : '로그인이 만료되어 잠급니다');
|
||||
const user = notReg ? (e.body?.user ?? this.state.user) : null;
|
||||
this.forget();
|
||||
this.set({ status: notReg ? 'not_registered' : 'signed_out', user, role: null, offline: false, error: notReg ? null : '로그인이 만료되었습니다. 다시 로그인해 주세요', verifiedAt: null });
|
||||
return this.state;
|
||||
}
|
||||
// 서버에 못 붙음: 마지막 확인이 유효 기간 안이면 그대로 쓴다
|
||||
const cache = this.settings.getSecret('auth');
|
||||
const grace = this.opts.offlineGraceMs ?? 3 * 24 * 3600 * 1000;
|
||||
const msg = `사이트 서버에 연결할 수 없습니다 (${e.message})`;
|
||||
if (cache && Date.now() - cache.verifiedAt < grace) {
|
||||
log.warn(`${msg} · 마지막 확인 결과로 계속 사용`);
|
||||
this.set({ status: 'ok', user: cache.user, role: cache.role, offline: true, error: msg, verifiedAt: cache.verifiedAt });
|
||||
} else {
|
||||
log.warn(msg);
|
||||
this.set({ status: 'error', offline: false, error: msg });
|
||||
}
|
||||
}
|
||||
return this.state;
|
||||
}
|
||||
|
||||
/** 브라우저로 디스코드 로그인. 끝나거나 취소될 때까지 기다린다 */
|
||||
async login(): Promise<AuthState> {
|
||||
const seq = ++this.loginSeq;
|
||||
let b: AppLoginBegin;
|
||||
try {
|
||||
b = await this.call<AppLoginBegin>('POST', '/auth/app/begin', {}, undefined);
|
||||
} catch (e: any) {
|
||||
this.set({ status: 'error', error: `사이트 서버에 연결할 수 없습니다 (${e.message})`, loginUrl: null });
|
||||
return this.state;
|
||||
}
|
||||
this.set({ status: 'waiting', error: null, loginUrl: b.url, user: null, role: null });
|
||||
await this.opts.openUrl(b.url);
|
||||
while (seq === this.loginSeq && Date.now() < b.expiresAt) {
|
||||
await new Promise((r) => setTimeout(r, this.opts.pollMs ?? 2000));
|
||||
if (seq !== this.loginSeq) break;
|
||||
let r: AppLoginPoll;
|
||||
try {
|
||||
r = await this.call<AppLoginPoll>('POST', '/auth/app/poll', { id: b.id, secret: b.secret }, undefined);
|
||||
} catch (e: any) {
|
||||
if (e instanceof HttpError) r = e.body?.state ? e.body : { state: 'error', error: e.message };
|
||||
else continue; // 잠깐 끊김: 계속 기다린다
|
||||
}
|
||||
if (seq !== this.loginSeq) break;
|
||||
if (r.state === 'pending') continue;
|
||||
if (r.state === 'ok') {
|
||||
this.settings.setSecret('appToken', r.token);
|
||||
this.state = { ...this.state, status: 'checking', loginUrl: null };
|
||||
log.info(`로그인: ${r.user.name} (${r.role})`);
|
||||
return this.check();
|
||||
}
|
||||
if (r.state === 'not_registered') {
|
||||
log.warn(`등록되지 않은 아이디로 로그인 시도: ${r.user.id}`);
|
||||
this.set({ status: 'not_registered', user: r.user, role: null, error: null, loginUrl: null });
|
||||
return this.state;
|
||||
}
|
||||
this.set({ status: 'signed_out', error: r.error, loginUrl: null });
|
||||
return this.state;
|
||||
}
|
||||
if (seq === this.loginSeq) this.set({ status: 'signed_out', error: '로그인 시간이 지났습니다. 다시 시도해 주세요', loginUrl: null });
|
||||
return this.state;
|
||||
}
|
||||
|
||||
cancelLogin(): void {
|
||||
this.loginSeq++;
|
||||
if (this.state.status === 'waiting') this.set({ status: 'signed_out', error: null, loginUrl: null });
|
||||
}
|
||||
|
||||
async logout(): Promise<void> {
|
||||
this.loginSeq++;
|
||||
const token = this.settings.getSecret('appToken');
|
||||
if (token) await this.call('POST', '/auth/app/logout', {}).catch(() => undefined);
|
||||
this.forget();
|
||||
this.set({ status: 'signed_out', user: null, role: null, offline: false, error: null, loginUrl: null, verifiedAt: null });
|
||||
}
|
||||
|
||||
// ---- 관리자 화면 (서버가 역할을 다시 확인한다)
|
||||
adminUsers(): Promise<{ users: AppUserRow[] }> {
|
||||
return this.call('GET', '/app/admin/users');
|
||||
}
|
||||
adminAddUser(id: string, role: 'admin' | 'user'): Promise<{ users: AppUserRow[] }> {
|
||||
return this.call('POST', '/app/admin/users', { id: id.trim(), role });
|
||||
}
|
||||
adminSetRole(id: string, role: 'admin' | 'user'): Promise<{ users: AppUserRow[] }> {
|
||||
return this.call('PATCH', `/app/admin/users/${encodeURIComponent(id)}`, { role });
|
||||
}
|
||||
adminRemoveUser(id: string): Promise<{ users: AppUserRow[] }> {
|
||||
return this.call('DELETE', `/app/admin/users/${encodeURIComponent(id)}`);
|
||||
}
|
||||
}
|
||||
@@ -1,32 +0,0 @@
|
||||
// 기본(겜녹이) 봇 토큰. 저장소에는 넣지 않는다.
|
||||
// 빌드할 때 build.mjs 가 GVR_BUILTIN_BOT_TOKEN 환경변수를 읽어 encodeBuiltinToken() 결과를
|
||||
// __GVR_BUILTIN_BOT__ 상수로 박는다 (esbuild define). 평문이 바이너리에 그대로 보이지 않게
|
||||
// XOR + base64 로 감출 뿐, 암호화는 아니다 - exe 를 풀면 꺼낼 수 있다.
|
||||
declare const __GVR_BUILTIN_BOT__: string | undefined;
|
||||
|
||||
const KEY = Buffer.from('gvr-gemnoki-builtin-bot', 'utf8');
|
||||
|
||||
function xor(b: Buffer): Buffer {
|
||||
const out = Buffer.alloc(b.length);
|
||||
for (let i = 0; i < b.length; i++) out[i] = b[i]! ^ KEY[i % KEY.length]! ^ ((i * 31) & 0xff);
|
||||
return out;
|
||||
}
|
||||
|
||||
export function encodeBuiltinToken(token: string): string {
|
||||
return xor(Buffer.from(token, 'utf8')).reverse().toString('base64');
|
||||
}
|
||||
|
||||
export function decodeBuiltinToken(blob: string): string {
|
||||
return xor(Buffer.from(blob, 'base64').reverse()).toString('utf8');
|
||||
}
|
||||
|
||||
/** 이 빌드에 들어 있는 겜녹이 봇 토큰. 개발 실행(tsx)이나 토큰 없이 만든 빌드는 null */
|
||||
export function builtinBotToken(): string | null {
|
||||
const blob = typeof __GVR_BUILTIN_BOT__ === 'string' ? __GVR_BUILTIN_BOT__ : '';
|
||||
if (!blob) return null;
|
||||
try {
|
||||
return decodeBuiltinToken(blob) || null;
|
||||
} catch {
|
||||
return null;
|
||||
}
|
||||
}
|
||||
@@ -26,6 +26,8 @@ export interface CoreOptions {
|
||||
worker: WorkerCommand;
|
||||
version: string;
|
||||
codec?: SecretCodec;
|
||||
/** 이미 연 설정 저장소 (Electron 은 로그인 확인 때문에 코어보다 먼저 연다) */
|
||||
settings?: SettingsStore;
|
||||
/** 로컬 API 를 127.0.0.1 포트로도 연다 (설정 창·디버그용). 0 이면 열지 않음 */
|
||||
apiPort?: number;
|
||||
}
|
||||
@@ -35,7 +37,7 @@ export type Core = Awaited<ReturnType<typeof startCore>>;
|
||||
/** 코어 조립 (Electron 메인 프로세스와 헤드리스 CLI 가 같이 쓴다) */
|
||||
export async function startCore(opts: CoreOptions) {
|
||||
fs.mkdirSync(opts.dataDir, { recursive: true });
|
||||
const settings = new SettingsStore(opts.dataDir, opts.codec);
|
||||
const settings = opts.settings ?? new SettingsStore(opts.dataDir, opts.codec);
|
||||
const S = () => settings.get();
|
||||
const paths = () => resolvePaths(opts.dataDir, S());
|
||||
initLogFile(paths().logs);
|
||||
|
||||
43
app/src/core/roles.ts
Normal file
43
app/src/core/roles.ts
Normal file
@@ -0,0 +1,43 @@
|
||||
// 역할별 권한: 일반 유저(user)가 바꿀 수 없는 관리자 전용 설정 · 기능.
|
||||
// 메인 프로세스(IPC)에서 막고, 설정 창은 같은 목록으로 잠금 표시만 한다.
|
||||
import type { AppRole } from '@gvr/shared';
|
||||
|
||||
export const isAdminRole = (r: AppRole | null | undefined): boolean => r === 'admin' || r === 'superadmin';
|
||||
|
||||
export const ROLE_LABEL: Record<AppRole, string> = { superadmin: '최고 관리자', admin: '관리자', user: '유저' };
|
||||
|
||||
/**
|
||||
* 관리자 전용 설정 (settings.json 경로 앞부분)
|
||||
* - 봇 선택: 다른 봇으로 바꾸기
|
||||
* - 녹음 안내(TTS): 녹음되는 사람들에게 알리는 장치라 끄거나 문구를 바꾸는 것은 관리자만
|
||||
* - 음성 보관 기간: 다른 사람 목소리를 얼마나 남길지 정하는 정책
|
||||
* - 사이트 서버: 주소 · PC 이름 · 등록 (모두가 보는 사이트에 연결되는 PC)
|
||||
* - 파인튜닝 일정 · 모델 교체
|
||||
*/
|
||||
export const ADMIN_ONLY_SETTINGS = ['discord.botMode', 'discord.ttsEnabled', 'discord.ttsOnNewMember', 'discord.ttsText', 'storage.retentionDays', 'site', 'finetune'] as const;
|
||||
|
||||
/** 관리자 전용 기능 (IPC 이름) */
|
||||
export const ADMIN_ONLY_ACTIONS = new Set([
|
||||
'registerDevice',
|
||||
'unregisterDevice',
|
||||
'setExcluded',
|
||||
'finetuneInstall',
|
||||
'finetuneStart',
|
||||
'finetuneStop',
|
||||
'finetuneRollback',
|
||||
'clearTrainingData',
|
||||
]);
|
||||
|
||||
/** 설정 변경(patch) 중 관리자 전용 항목의 경로 목록. 비어 있으면 누구나 바꿀 수 있는 변경 */
|
||||
export function adminOnlyPaths(patch: unknown, prefix = ''): string[] {
|
||||
if (!patch || typeof patch !== 'object' || Array.isArray(patch)) return [];
|
||||
const out: string[] = [];
|
||||
for (const [k, v] of Object.entries(patch)) {
|
||||
const p = prefix ? `${prefix}.${k}` : k;
|
||||
if (ADMIN_ONLY_SETTINGS.some((a) => p === a || p.startsWith(`${a}.`))) out.push(p);
|
||||
else if (ADMIN_ONLY_SETTINGS.some((a) => a.startsWith(`${p}.`))) out.push(...adminOnlyPaths(v, p));
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
export const ADMIN_ONLY_MESSAGE = '관리자만 바꿀 수 있는 설정입니다';
|
||||
@@ -1,6 +1,6 @@
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { builtinBotToken } from './builtin-bot.js';
|
||||
import type { AppRole, AppUserInfo } from '@gvr/shared';
|
||||
|
||||
export interface Settings {
|
||||
version: 1;
|
||||
@@ -69,6 +69,12 @@ export interface Secrets {
|
||||
botToken?: string;
|
||||
deviceKey?: string;
|
||||
riotApiKey?: string;
|
||||
/** 앱 로그인 토큰 (사이트 서버가 발급) */
|
||||
appToken?: string;
|
||||
/** 겜녹이 기본 봇 토큰. exe 에 들어 있지 않고, 로그인한 등록 유저에게 사이트 서버가 내려준다 */
|
||||
builtinBotToken?: string;
|
||||
/** 마지막으로 서버에서 확인한 로그인 정보 (서버에 잠깐 못 붙을 때 쓰는 사본) */
|
||||
auth?: { user: AppUserInfo; role: AppRole; verifiedAt: number };
|
||||
}
|
||||
|
||||
export const DEFAULT_TTS_TEXT =
|
||||
@@ -148,17 +154,14 @@ export class SettingsStore {
|
||||
private secrets: Secrets;
|
||||
private listeners = new Set<(s: Settings) => void>();
|
||||
|
||||
private builtinBot: string | null;
|
||||
private envBotToken: string | null;
|
||||
|
||||
constructor(
|
||||
private dataDir: string,
|
||||
private codec: SecretCodec = plainCodec,
|
||||
opts: { builtinBotToken?: string | null } = {},
|
||||
) {
|
||||
this.file = path.join(dataDir, 'settings.json');
|
||||
this.secretFile = path.join(dataDir, 'secrets.bin');
|
||||
this.builtinBot = opts.builtinBotToken !== undefined ? opts.builtinBotToken : builtinBotToken();
|
||||
this.cur = defaultSettings();
|
||||
let saved: any = null;
|
||||
try {
|
||||
@@ -179,14 +182,14 @@ export class SettingsStore {
|
||||
this.envBotToken = process.env.GVR_BOT_TOKEN || null;
|
||||
}
|
||||
|
||||
/** 이 빌드에 겜녹이 기본 봇이 들어 있는지 */
|
||||
/** 겜녹이 기본 봇 토큰을 받아 두었는지 (로그인하면 사이트 서버가 내려준다) */
|
||||
get hasBuiltinBot(): boolean {
|
||||
return !!this.builtinBot;
|
||||
return !!this.secrets.builtinBotToken;
|
||||
}
|
||||
/** 지금 모드에서 봇이 로그인할 토큰 (없으면 null) */
|
||||
activeBotToken(): string | null {
|
||||
if (this.envBotToken) return this.envBotToken;
|
||||
return this.cur.discord.botMode === 'builtin' ? this.builtinBot : this.secrets.botToken || null;
|
||||
return (this.cur.discord.botMode === 'builtin' ? this.secrets.builtinBotToken : this.secrets.botToken) || null;
|
||||
}
|
||||
|
||||
get(): Settings {
|
||||
|
||||
@@ -10,6 +10,7 @@ const listeners = new Set<(line: string) => void>();
|
||||
export function initLogFile(dir: string): void {
|
||||
fs.mkdirSync(dir, { recursive: true });
|
||||
const day = new Date().toISOString().slice(0, 10);
|
||||
stream?.end(); // 로그아웃 후 다시 로그인하면 코어를 다시 띄운다
|
||||
stream = fs.createWriteStream(path.join(dir, `gvr-${day}.log`), { flags: 'a' });
|
||||
}
|
||||
export function setLogLevel(l: Level): void {
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
// 설정 창(렌더러) ↔ Electron 메인 프로세스 IPC 계약. preload 가 window.gvr 로 노출한다.
|
||||
import type { User } from '@gvr/shared';
|
||||
import type { AppRole, AppUserInfo, AppUserRow, User } from '@gvr/shared';
|
||||
import type { AuthState } from '../core/auth.js';
|
||||
import type { DiagItem } from '../core/diagnostics.js';
|
||||
import type { BotState } from '../core/discord/bot.js';
|
||||
import type { RelayStatus } from '../core/relay/client.js';
|
||||
@@ -40,12 +41,23 @@ export interface FinetuneStatus {
|
||||
log: string[];
|
||||
}
|
||||
|
||||
/** 로그인 화면용 상태. appReady = 로그인 후 코어(봇 · 녹음)가 다 떴는지 */
|
||||
export interface AuthView extends AuthState {
|
||||
appReady: boolean;
|
||||
/** 로그인 후 코어 시작 실패 */
|
||||
appError: string | null;
|
||||
version: string;
|
||||
serverUrl: string;
|
||||
}
|
||||
|
||||
export interface AppState {
|
||||
/** 로그인한 계정 · 역할 (user 는 관리자 전용 설정을 못 바꾼다) */
|
||||
account: { user: AppUserInfo | null; role: AppRole | null; offline: boolean };
|
||||
version: string;
|
||||
dataDir: string;
|
||||
portable: boolean;
|
||||
settings: Settings;
|
||||
/** 이 빌드에 겜녹이 기본 봇 토큰이 들어 있는지 */
|
||||
/** 겜녹이 기본 봇 토큰을 서버에서 받아 두었는지 */
|
||||
builtinBot: boolean;
|
||||
secrets: { botToken: boolean; riotApiKey: boolean; deviceKey: boolean };
|
||||
secretCodec: string;
|
||||
@@ -60,6 +72,16 @@ export interface AppState {
|
||||
}
|
||||
|
||||
export interface GvrApi {
|
||||
authState(): Promise<AuthView>;
|
||||
onAuth(cb: (s: AuthView) => void): () => void;
|
||||
authLogin(): Promise<AuthView>;
|
||||
authCancel(): Promise<void>;
|
||||
authLogout(): Promise<void>;
|
||||
authRecheck(): Promise<AuthView>;
|
||||
adminUsers(): Promise<{ users: AppUserRow[] }>;
|
||||
adminAddUser(id: string, role: 'admin' | 'user'): Promise<{ users: AppUserRow[] }>;
|
||||
adminSetRole(id: string, role: 'admin' | 'user'): Promise<{ users: AppUserRow[] }>;
|
||||
adminRemoveUser(id: string): Promise<{ users: AppUserRow[] }>;
|
||||
getState(): Promise<AppState>;
|
||||
onState(cb: (s: AppState) => void): () => void;
|
||||
updateSettings(patch: DeepPartial<Settings>): Promise<Settings>;
|
||||
|
||||
@@ -2,19 +2,22 @@ import { app, BrowserWindow, dialog, ipcMain, shell } from 'electron';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { toUser } from '../core/api/server.js';
|
||||
import type { AppAuth, AuthState } from '../core/auth.js';
|
||||
import { runDiagnostics } from '../core/diagnostics.js';
|
||||
import { synthesize } from '../core/discord/tts.js';
|
||||
import type { Core } from '../core/index.js';
|
||||
import { registerDevice } from '../core/relay/client.js';
|
||||
import { dirSize } from '../core/retention.js';
|
||||
import type { AppState, DownloadProgress, GvrApi } from './api-types.js';
|
||||
import { ADMIN_ONLY_ACTIONS, ADMIN_ONLY_MESSAGE, adminOnlyPaths, isAdminRole } from '../core/roles.js';
|
||||
import type { AppState, AuthView, DownloadProgress, GvrApi } from './api-types.js';
|
||||
import type { Finetuner } from './finetune.js';
|
||||
|
||||
type Handlers = { [K in keyof GvrApi]?: (...args: any[]) => any };
|
||||
|
||||
export function buildState(core: Core, opts: { dataDir: string; portable: boolean }): AppState {
|
||||
export function buildState(core: Core, opts: { dataDir: string; portable: boolean; auth: AuthState }): AppState {
|
||||
const s = core.settings.get();
|
||||
return {
|
||||
account: { user: opts.auth.user, role: opts.auth.role, offline: opts.auth.offline },
|
||||
version: core.version,
|
||||
dataDir: opts.dataDir,
|
||||
portable: opts.portable,
|
||||
@@ -36,15 +39,51 @@ export function buildState(core: Core, opts: { dataDir: string; portable: boolea
|
||||
};
|
||||
}
|
||||
|
||||
/** 설정 창의 window.gvr 요청 처리 (api-types.ts GvrApi) */
|
||||
export function registerIpc(core: Core, ft: Finetuner, ctx: { dataDir: string; portable: boolean; win: () => BrowserWindow | null; finishWizard: () => void; quit: () => void }) {
|
||||
export interface IpcContext {
|
||||
dataDir: string;
|
||||
portable: boolean;
|
||||
win: () => BrowserWindow | null;
|
||||
finishWizard: () => void;
|
||||
quit: () => void;
|
||||
auth: AppAuth;
|
||||
/** 로그인해서 코어가 떠 있으면 코어 · 파인튜너 */
|
||||
current: () => { core: Core; ft: Finetuner } | null;
|
||||
authView: () => AuthView;
|
||||
/** 로그인 화면에서 다시 확인 (서버 연결 실패 후 재시도) */
|
||||
recheck: () => Promise<void>;
|
||||
}
|
||||
|
||||
/** 설정 창의 window.gvr 요청 처리 (api-types.ts GvrApi). 로그인 · 관리자 요청은 코어 없이도 받는다 */
|
||||
export function registerIpc(ctx: IpcContext) {
|
||||
const send = (ch: string, payload: unknown) => ctx.win()?.webContents.send(ch, payload);
|
||||
const progress = (p: DownloadProgress) => send('gvr:progress', p);
|
||||
const role = () => (ctx.auth.ok ? ctx.auth.state.role : null);
|
||||
|
||||
// 로그인해야 쓰는 요청은 지금 떠 있는 코어로 보낸다 (로그아웃 후 다시 로그인하면 코어가 새로 뜬다)
|
||||
const live = () => {
|
||||
const c = ctx.auth.ok ? ctx.current() : null;
|
||||
if (!c) throw new Error('로그인이 필요합니다');
|
||||
return c;
|
||||
};
|
||||
const core = new Proxy({} as Core, { get: (_t, k) => (live().core as any)[k] });
|
||||
const ft = new Proxy({} as Finetuner, {
|
||||
get: (_t, k) => {
|
||||
const f = live().ft as any;
|
||||
return typeof f[k] === 'function' ? f[k].bind(f) : f[k];
|
||||
},
|
||||
});
|
||||
|
||||
const h: Handlers = {
|
||||
getState: () => buildState(core, ctx),
|
||||
updateSettings: (patch) => core.settings.update(patch),
|
||||
setSecret: (key, value) => core.settings.setSecret(key, value),
|
||||
getState: () => buildState(core, { ...ctx, auth: ctx.auth.state }),
|
||||
updateSettings: (patch) => {
|
||||
if (!isAdminRole(role()) && adminOnlyPaths(patch).length) throw new Error(ADMIN_ONLY_MESSAGE);
|
||||
return core.settings.update(patch);
|
||||
},
|
||||
setSecret: (key, value) => {
|
||||
if (key !== 'botToken' && key !== 'riotApiKey') throw new Error('바꿀 수 없는 값입니다');
|
||||
if (key === 'botToken' && !isAdminRole(role())) throw new Error(ADMIN_ONLY_MESSAGE);
|
||||
return core.settings.setSecret(key, value);
|
||||
},
|
||||
|
||||
testBotToken: async (token?: string) => {
|
||||
const t = token || core.settings.activeBotToken();
|
||||
@@ -283,7 +322,26 @@ export function registerIpc(core: Core, ft: Finetuner, ctx: { dataDir: string; p
|
||||
quit: () => ctx.quit(),
|
||||
};
|
||||
|
||||
const authHandlers: Handlers = {
|
||||
authState: () => ctx.authView(),
|
||||
authLogin: () => ctx.auth.login().then(() => ctx.authView()),
|
||||
authCancel: () => ctx.auth.cancelLogin(),
|
||||
authLogout: () => ctx.auth.logout(),
|
||||
authRecheck: () => ctx.recheck().then(() => ctx.authView()),
|
||||
adminUsers: () => ctx.auth.adminUsers(),
|
||||
adminAddUser: (id: string, r: 'admin' | 'user') => ctx.auth.adminAddUser(id, r),
|
||||
adminSetRole: (id: string, r: 'admin' | 'user') => ctx.auth.adminSetRole(id, r),
|
||||
adminRemoveUser: (id: string) => ctx.auth.adminRemoveUser(id),
|
||||
openExternal: h.openExternal,
|
||||
quit: h.quit,
|
||||
};
|
||||
for (const [name, fn] of Object.entries(authHandlers)) ipcMain.handle(`gvr:${name}`, async (_e, ...args) => fn!(...args));
|
||||
for (const [name, fn] of Object.entries(h)) {
|
||||
ipcMain.handle(`gvr:${name}`, async (_e, ...args) => fn!(...args));
|
||||
if (name in authHandlers) continue;
|
||||
ipcMain.handle(`gvr:${name}`, async (_e, ...args) => {
|
||||
live();
|
||||
if (ADMIN_ONLY_ACTIONS.has(name) && !isAdminRole(role())) throw new Error('관리자만 쓸 수 있는 기능입니다');
|
||||
return fn!(...args);
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2,10 +2,12 @@
|
||||
import { app, BrowserWindow, Menu, nativeImage, safeStorage, shell, Tray } from 'electron';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import { AppAuth } from '../core/auth.js';
|
||||
import { startCore, type Core } from '../core/index.js';
|
||||
import { plainCodec, type SecretCodec } from '../core/settings.js';
|
||||
import { plainCodec, SettingsStore, type SecretCodec } from '../core/settings.js';
|
||||
import { logger } from '../core/util/log.js';
|
||||
import { Finetuner } from './finetune.js';
|
||||
import type { AuthView } from './api-types.js';
|
||||
import { buildState, registerIpc } from './ipc.js';
|
||||
import { brandDir, rendererDir, resolveDataDir, resourcesDir, workerCommand } from './paths.js';
|
||||
|
||||
@@ -23,6 +25,9 @@ if (!SMOKE && !app.requestSingleInstanceLock()) {
|
||||
|
||||
let core: Core | null = null;
|
||||
let ft: Finetuner | null = null;
|
||||
// 로그인: 설정 저장소와 로그인 확인은 코어보다 먼저 연다. 등록된 아이디로 로그인해야 코어(봇 · 녹음 · 사이트 연결)를 띄운다
|
||||
let settings: SettingsStore | null = null;
|
||||
let auth: AppAuth | null = null;
|
||||
let win: BrowserWindow | null = null;
|
||||
let tray: Tray | null = null;
|
||||
let quitting = false;
|
||||
@@ -43,8 +48,9 @@ function trayImage(state: 'idle' | 'rec' | 'off'): Electron.NativeImage {
|
||||
}
|
||||
|
||||
function openWindow(route?: string): void {
|
||||
if (!core) return;
|
||||
const r = route ?? (core.settings.get().firstRunDone ? '/settings/discord' : '/wizard');
|
||||
if (!settings) return;
|
||||
const first = settings.get().firstRunDone;
|
||||
const r = route ?? (first ? '/settings/discord' : '/wizard');
|
||||
if (win && !win.isDestroyed()) {
|
||||
win.webContents.executeJavaScript(`location.hash = ${JSON.stringify('#' + r)}`).catch(() => undefined);
|
||||
win.show();
|
||||
@@ -56,7 +62,7 @@ function openWindow(route?: string): void {
|
||||
height: 760,
|
||||
minWidth: 960,
|
||||
minHeight: 640,
|
||||
title: core.settings.get().firstRunDone ? '겜녹이 · 설정' : '겜녹이 · 첫 실행 설정',
|
||||
title: first ? '겜녹이 · 설정' : '겜녹이 · 첫 실행 설정',
|
||||
icon: path.join(brandDir(), 'icon.png'),
|
||||
backgroundColor: '#0b141c',
|
||||
autoHideMenuBar: true,
|
||||
@@ -81,7 +87,12 @@ function openWindow(route?: string): void {
|
||||
}
|
||||
|
||||
function updateTray(): void {
|
||||
if (!tray || !core) return;
|
||||
if (!tray) return;
|
||||
if (!core) {
|
||||
tray.setImage(trayImage('off'));
|
||||
tray.setToolTip(`겜녹이\n${auth?.state.status === 'not_registered' ? '등록되지 않은 아이디' : '로그인이 필요합니다'}`);
|
||||
return;
|
||||
}
|
||||
const st = core.bot.state;
|
||||
const rel = core.relay.status;
|
||||
const rec = st.recording.active;
|
||||
@@ -96,7 +107,17 @@ function updateTray(): void {
|
||||
}
|
||||
|
||||
function buildTrayMenu(): void {
|
||||
if (!tray || !core) return;
|
||||
if (!tray) return;
|
||||
if (!core) {
|
||||
tray.setContextMenu(
|
||||
Menu.buildFromTemplate([
|
||||
{ label: '겜녹이 로그인', click: () => openWindow() },
|
||||
{ type: 'separator' },
|
||||
{ label: '종료', click: () => void quit() },
|
||||
]),
|
||||
);
|
||||
return;
|
||||
}
|
||||
const c = core;
|
||||
tray.setContextMenu(
|
||||
Menu.buildFromTemplate([
|
||||
@@ -116,8 +137,8 @@ async function quit(): Promise<void> {
|
||||
if (quitting) return;
|
||||
quitting = true;
|
||||
try {
|
||||
ft?.dispose();
|
||||
await core?.stop();
|
||||
auth?.cancelLogin();
|
||||
await stopApp();
|
||||
} catch (e) {
|
||||
log.error('종료 중 오류', e);
|
||||
}
|
||||
@@ -130,9 +151,13 @@ async function smoke(): Promise<void> {
|
||||
const out: Record<string, unknown> = { version: app.getVersion(), dataDir, resources: resourcesDir() };
|
||||
let code = 1;
|
||||
try {
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), codec: dpapiCodec() });
|
||||
const st = new SettingsStore(dataDir, dpapiCodec());
|
||||
// 로그인: 토큰이 없는 새 설치는 로그인 화면(signed_out)이어야 한다. exe 에는 겜녹이 봇 토큰이 없어야 한다
|
||||
const a = await new AppAuth(st, { version: app.getVersion(), openUrl: () => undefined }).check();
|
||||
out.auth = a.status;
|
||||
out.builtinBot = st.hasBuiltinBot;
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), settings: st });
|
||||
out.codec = c.settings.codecName;
|
||||
out.builtinBot = c.settings.hasBuiltinBot;
|
||||
out.botMode = c.settings.get().discord.botMode;
|
||||
const ready = await new Promise<any>((res) => {
|
||||
if (c.worker.ready) return res(true);
|
||||
@@ -143,10 +168,9 @@ async function smoke(): Promise<void> {
|
||||
});
|
||||
});
|
||||
out.worker = ready;
|
||||
// 봇: 로그인이 끝나(ready/error) 길 최대 30초 기다린다. 기본 봇이 들어 있는 빌드면 ready 여야 통과
|
||||
for (let i = 0; i < 60 && c.bot.state.status === 'connecting'; i++) await new Promise((r) => setTimeout(r, 500));
|
||||
out.bot = { status: c.bot.state.status, user: c.bot.state.user?.name ?? null, guilds: c.bot.state.guilds.length, error: c.bot.state.error };
|
||||
const botOk = !c.settings.hasBuiltinBot || c.bot.state.status === 'ready';
|
||||
// 봇: 로그인 전이라 봇 토큰이 없으니 봇은 꺼져 있어야 한다 (토큰이 exe 에 들어 있지 않다는 확인)
|
||||
out.bot = { status: c.bot.state.status, error: c.bot.state.error };
|
||||
const botOk = a.status === 'signed_out' && !st.hasBuiltinBot && c.bot.state.status !== 'ready';
|
||||
out.gpu = await c.worker.request('gpu_info', {}, 30000).catch((e) => String(e));
|
||||
c.settings.setSecret('riotApiKey', 'smoke-test');
|
||||
out.secretRoundTrip = c.settings.getSecret('riotApiKey') === 'smoke-test';
|
||||
@@ -164,29 +188,130 @@ async function smoke(): Promise<void> {
|
||||
app.exit(code);
|
||||
}
|
||||
|
||||
/** 로그인은 됐는데 코어가 못 뜬 경우의 오류 (로그인 화면에 보여 준다) */
|
||||
let appError: string | null = null;
|
||||
const authView = (): AuthView => ({ ...auth!.state, appReady: !!core, appError, version: app.getVersion(), serverUrl: settings!.get().site.serverUrl });
|
||||
const pushAuth = () => {
|
||||
if (win && !win.isDestroyed()) win.webContents.send('gvr:auth', authView());
|
||||
};
|
||||
const pushState = () => {
|
||||
if (core && auth && win && !win.isDestroyed() && win.isVisible()) win.webContents.send('gvr:state', buildState(core, { dataDir, portable: app.isPackaged, auth: auth.state }));
|
||||
};
|
||||
const refreshShell = () => {
|
||||
pushAuth();
|
||||
buildTrayMenu();
|
||||
updateTray();
|
||||
};
|
||||
|
||||
let starting: Promise<void> | null = null;
|
||||
/** 서버에서 받은 겜녹이 봇 토큰. 서버에서 바뀌면 봇을 다시 연결한다 */
|
||||
let builtinSeen: string | null = null;
|
||||
|
||||
/** 로그인 확인 후 코어 시작 */
|
||||
function startApp(): Promise<void> {
|
||||
if (core) return Promise.resolve();
|
||||
starting ??= (async () => {
|
||||
try {
|
||||
const c = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), settings: settings! });
|
||||
core = c;
|
||||
builtinSeen = c.settings.getSecret('builtinBotToken') ?? null;
|
||||
ft = new Finetuner(c, pushState);
|
||||
ft.scheduleNightly();
|
||||
appError = null;
|
||||
} catch (e: any) {
|
||||
log.error('코어 시작 실패', e);
|
||||
appError = `겜녹이를 시작하지 못했습니다: ${e?.message ?? e}`;
|
||||
} finally {
|
||||
starting = null;
|
||||
refreshShell();
|
||||
}
|
||||
})();
|
||||
return starting;
|
||||
}
|
||||
|
||||
/** 로그아웃 · 등록 해제: 봇 · 녹음 · 사이트 연결을 모두 멈춘다 */
|
||||
async function stopApp(): Promise<void> {
|
||||
if (starting) await starting;
|
||||
if (!core) return;
|
||||
const c = core;
|
||||
core = null;
|
||||
ft?.dispose();
|
||||
ft = null;
|
||||
try {
|
||||
await c.stop();
|
||||
} finally {
|
||||
refreshShell();
|
||||
}
|
||||
}
|
||||
|
||||
let authChain: Promise<void> = Promise.resolve();
|
||||
function onAuthChange(): void {
|
||||
authChain = authChain
|
||||
.then(async () => {
|
||||
if (quitting) return;
|
||||
pushAuth();
|
||||
const st = auth!.state.status;
|
||||
if (st === 'ok') {
|
||||
if (!core) return startApp();
|
||||
const t = core.settings.getSecret('builtinBotToken') ?? null;
|
||||
if (t !== builtinSeen) {
|
||||
builtinSeen = t;
|
||||
if (core.settings.get().discord.botMode === 'builtin') {
|
||||
log.info('서버에서 받은 겜녹이 봇 토큰이 바뀌어 봇을 다시 연결합니다');
|
||||
await core.bot.stop();
|
||||
await core.startBot();
|
||||
}
|
||||
}
|
||||
} else if (st !== 'checking' && st !== 'waiting') {
|
||||
await stopApp();
|
||||
openWindow();
|
||||
}
|
||||
})
|
||||
.catch((e) => log.error('로그인 상태 처리 실패', e));
|
||||
}
|
||||
|
||||
app.whenReady().then(async () => {
|
||||
if (SMOKE) return smoke();
|
||||
core = await startCore({ dataDir, resourcesDir: resourcesDir(), worker: workerCommand(), version: app.getVersion(), codec: dpapiCodec() });
|
||||
const c = core;
|
||||
ft = new Finetuner(c, () => win?.webContents.send('gvr:state', buildState(c, { dataDir, portable: app.isPackaged })));
|
||||
ft.scheduleNightly();
|
||||
registerIpc(c, ft, {
|
||||
settings = new SettingsStore(dataDir, dpapiCodec());
|
||||
auth = new AppAuth(settings, { version: app.getVersion(), openUrl: (u) => shell.openExternal(u) });
|
||||
const a = auth;
|
||||
registerIpc({
|
||||
dataDir,
|
||||
portable: app.isPackaged,
|
||||
win: () => (win && !win.isDestroyed() ? win : null),
|
||||
finishWizard: () => win?.setTitle('겜녹이 · 설정'),
|
||||
quit: () => void quit(),
|
||||
auth: a,
|
||||
current: () => (core && ft ? { core, ft } : null),
|
||||
authView,
|
||||
recheck: async () => {
|
||||
await a.check();
|
||||
await authChain;
|
||||
if (starting) await starting;
|
||||
},
|
||||
});
|
||||
tray = new Tray(trayImage('off'));
|
||||
tray.on('click', () => openWindow());
|
||||
buildTrayMenu();
|
||||
updateTray();
|
||||
refreshShell();
|
||||
a.on('change', onAuthChange);
|
||||
// 시작할 때 확인 → 10분마다 다시 확인 (등록 해제되면 바로 잠김). 서버에 못 붙어 막힌 상태면 1분마다 다시 시도
|
||||
let lastCheck = Date.now();
|
||||
const first = a.check();
|
||||
setInterval(() => {
|
||||
const st = a.state.status;
|
||||
if ((st === 'ok' && Date.now() - lastCheck > 10 * 60000) || (st === 'error' && Date.now() - lastCheck > 60000) || (st === 'ok' && a.state.offline && Date.now() - lastCheck > 60000)) {
|
||||
lastCheck = Date.now();
|
||||
void a.check();
|
||||
}
|
||||
}, 15000);
|
||||
setInterval(() => {
|
||||
updateTray();
|
||||
buildTrayMenu();
|
||||
if (win && !win.isDestroyed() && win.isVisible()) win.webContents.send('gvr:state', buildState(c, { dataDir, portable: app.isPackaged }));
|
||||
pushState();
|
||||
}, 1500);
|
||||
if (!flag('hidden') || !c.settings.get().firstRunDone) openWindow();
|
||||
await first;
|
||||
await authChain;
|
||||
if (!flag('hidden') || !settings.get().firstRunDone || !a.ok) openWindow();
|
||||
if (process.env.GVR_CAPTURE_DIR) void captureScreens(process.env.GVR_CAPTURE_DIR);
|
||||
});
|
||||
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
import { contextBridge, ipcRenderer } from 'electron';
|
||||
|
||||
// window.gvr — api-types.ts 의 GvrApi. 이벤트 3개(onState, onProgress, onDiag)만 구독형이고 나머지는 invoke.
|
||||
// window.gvr — api-types.ts 의 GvrApi. 이벤트 4개(onState, onProgress, onDiag, onAuth)만 구독형이고 나머지는 invoke.
|
||||
const METHODS = [
|
||||
'getState', 'updateSettings', 'setSecret', 'testBotToken', 'restartBot', 'guildMembers', 'previewTts', 'gpuInfo', 'models',
|
||||
'download', 'deleteModel', 'applyModels', 'chooseFolder', 'registerDevice', 'unregisterDevice', 'runDiagnostics', 'storageUsage',
|
||||
'runRetention', 'users', 'setRiotIds', 'setExcluded', 'dictionary', 'addWord', 'addCorrection', 'deleteDict', 'setDictEnabled',
|
||||
'finetuneStatus', 'finetuneInstall', 'finetuneStart', 'finetuneStop', 'finetuneRollback', 'clearTrainingData', 'openExternal',
|
||||
'openPath', 'setAutoStart', 'finishWizard', 'recentLogs', 'quit',
|
||||
'authState', 'authLogin', 'authCancel', 'authLogout', 'authRecheck', 'adminUsers', 'adminAddUser', 'adminSetRole', 'adminRemoveUser',
|
||||
];
|
||||
const api: Record<string, unknown> = {};
|
||||
for (const m of METHODS) api[m] = (...args: unknown[]) => ipcRenderer.invoke(`gvr:${m}`, ...args);
|
||||
@@ -18,4 +19,5 @@ const sub = (ch: string) => (cb: (v: unknown) => void) => {
|
||||
api.onState = sub('gvr:state');
|
||||
api.onProgress = sub('gvr:progress');
|
||||
api.onDiag = sub('gvr:diag');
|
||||
api.onAuth = sub('gvr:auth');
|
||||
contextBridge.exposeInMainWorld('gvr', api);
|
||||
|
||||
143
app/src/renderer/auth/Login.tsx
Normal file
143
app/src/renderer/auth/Login.tsx
Normal file
@@ -0,0 +1,143 @@
|
||||
// 로그인 화면 + 로그인 게이트. 등록된 디스코드 아이디로 로그인해야 설정 창(과 봇 · 녹음)이 열린다
|
||||
import { useEffect, useState, type ReactNode } from 'react';
|
||||
import type { AuthView } from '../../main/api-types';
|
||||
import banner from '../assets/banner.png';
|
||||
import { gvr } from '../store';
|
||||
import { Avatar, Btn, Err, Spinner } from '../ui';
|
||||
import { errMsg } from '../util';
|
||||
|
||||
export function AuthGate({ children }: { children: ReactNode }) {
|
||||
const [auth, setAuth] = useState<AuthView | null>(null);
|
||||
const [loadError, setLoadError] = useState<string | null>(null);
|
||||
useEffect(() => {
|
||||
let alive = true;
|
||||
gvr.authState().then(
|
||||
(s) => alive && setAuth(s),
|
||||
(e) => alive && setLoadError(errMsg(e)),
|
||||
);
|
||||
const off = gvr.onAuth((s) => setAuth(s));
|
||||
return () => {
|
||||
alive = false;
|
||||
off();
|
||||
};
|
||||
}, []);
|
||||
if (!auth) return <div className="boot">{loadError ? <div className="err">메인 프로세스에 연결하지 못했습니다: {loadError}</div> : <Spinner big />}</div>;
|
||||
if (auth.status === 'ok' && auth.appReady) return <>{children}</>;
|
||||
return <LoginScreen auth={auth} />;
|
||||
}
|
||||
|
||||
function LoginScreen({ auth }: { auth: AuthView }) {
|
||||
const [error, setError] = useState<string | null>(null);
|
||||
const [copied, setCopied] = useState(false);
|
||||
useEffect(() => {
|
||||
document.title = '겜녹이 · 로그인';
|
||||
}, []);
|
||||
const login = async () => {
|
||||
setError(null);
|
||||
try {
|
||||
await gvr.authLogin();
|
||||
} catch (e) {
|
||||
setError(errMsg(e));
|
||||
}
|
||||
};
|
||||
const st = auth.status;
|
||||
const host = auth.serverUrl.replace(/^https?:\/\//, '');
|
||||
|
||||
let body: ReactNode;
|
||||
if (st === 'ok' && !auth.appReady && auth.appError) {
|
||||
body = (
|
||||
<>
|
||||
<Err>{auth.appError}</Err>
|
||||
<div className="muted small">로그인은 되었습니다. 겜녹이를 종료한 뒤 다시 실행해 주세요. 계속되면 GVR-Data\logs 의 로그를 관리자에게 보내 주세요.</div>
|
||||
</>
|
||||
);
|
||||
} else if (st === 'checking' || (st === 'ok' && !auth.appReady)) {
|
||||
body = (
|
||||
<div className="row gap muted">
|
||||
<Spinner /> {st === 'ok' ? '겜녹이를 시작하는 중…' : '로그인 확인 중…'}
|
||||
</div>
|
||||
);
|
||||
} else if (st === 'waiting') {
|
||||
body = (
|
||||
<>
|
||||
<div className="row gap">
|
||||
<Spinner /> 브라우저에서 디스코드 로그인을 마쳐 주세요
|
||||
</div>
|
||||
<div className="hint">
|
||||
브라우저가 열리지 않았다면{' '}
|
||||
<a href="#" onClick={(e) => (e.preventDefault(), auth.loginUrl && void gvr.openExternal(auth.loginUrl))}>
|
||||
로그인 페이지 다시 열기 ↗
|
||||
</a>
|
||||
</div>
|
||||
<div className="row end">
|
||||
<Btn onClick={() => gvr.authCancel()}>취소</Btn>
|
||||
</div>
|
||||
</>
|
||||
);
|
||||
} else if (st === 'not_registered') {
|
||||
body = (
|
||||
<>
|
||||
<div className="login-bad">⛔ 등록되지 않은 아이디입니다</div>
|
||||
{auth.user && (
|
||||
<div className="login-who">
|
||||
<Avatar name={auth.user.name} src={auth.user.avatar} size={32} />
|
||||
<div className="grow">
|
||||
<div>{auth.user.name}</div>
|
||||
<div className="id">{auth.user.id}</div>
|
||||
</div>
|
||||
<Btn
|
||||
small
|
||||
onClick={async () => {
|
||||
await navigator.clipboard.writeText(auth.user!.id).catch(() => undefined);
|
||||
setCopied(true);
|
||||
}}
|
||||
>
|
||||
{copied ? '복사됨 ✓' : '아이디 복사'}
|
||||
</Btn>
|
||||
</div>
|
||||
)}
|
||||
<div className="muted small">이 계정은 겜녹이를 쓸 수 없습니다. 관리자에게 위 디스코드 아이디 등록을 요청한 뒤 다시 로그인해 주세요.</div>
|
||||
<Btn primary onClick={login}>
|
||||
다시 로그인
|
||||
</Btn>
|
||||
</>
|
||||
);
|
||||
} else {
|
||||
body = (
|
||||
<>
|
||||
<div className="muted small">등록된 디스코드 계정으로 로그인해야 겜녹이를 쓸 수 있습니다. 로그인 버튼을 누르면 브라우저에서 디스코드 로그인 창이 열립니다.</div>
|
||||
{st === 'error' && (
|
||||
<div className="row gap">
|
||||
<Err>{auth.error}</Err>
|
||||
<span className="grow" />
|
||||
<Btn small onClick={() => gvr.authRecheck()}>
|
||||
다시 시도
|
||||
</Btn>
|
||||
</div>
|
||||
)}
|
||||
{st === 'signed_out' && auth.error && <Err>{auth.error}</Err>}
|
||||
<Btn primary onClick={login}>
|
||||
디스코드로 로그인
|
||||
</Btn>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
return (
|
||||
<div className="login">
|
||||
<div className="login-card">
|
||||
<img className="banner" src={banner} alt="겜녹이" />
|
||||
<div className="h login-title">로그인</div>
|
||||
{body}
|
||||
<Err>{error}</Err>
|
||||
<div className="login-foot">
|
||||
겜녹이 v{auth.version} · {host}
|
||||
<span className="grow" />
|
||||
<Btn small ghost onClick={() => gvr.quit()}>
|
||||
종료
|
||||
</Btn>
|
||||
</div>
|
||||
</div>
|
||||
</div>
|
||||
);
|
||||
}
|
||||
@@ -1,9 +1,12 @@
|
||||
// 겜녹이 설정 창 렌더러 진입점. 라우팅: #/wizard[/단계] · #/settings/<탭>
|
||||
import { useEffect, useState, type ReactNode } from 'react';
|
||||
import { createRoot } from 'react-dom/client';
|
||||
import { ROLE_LABEL, isAdminRole } from '../core/roles';
|
||||
import tray from './assets/tray@2x.png';
|
||||
import { AuthGate } from './auth/Login';
|
||||
import { AppProvider, isMock, useApp } from './store';
|
||||
import './styles.css';
|
||||
import { AdminTab } from './tabs/AdminTab';
|
||||
import { AudioTab } from './tabs/AudioTab';
|
||||
import { DiagTab } from './tabs/DiagTab';
|
||||
import { DictTab } from './tabs/DictTab';
|
||||
@@ -12,7 +15,7 @@ import { GamesTab } from './tabs/GamesTab';
|
||||
import { GeneralTab } from './tabs/GeneralTab';
|
||||
import { StorageTab } from './tabs/StorageTab';
|
||||
import { SttTab } from './tabs/SttTab';
|
||||
import { Dot } from './ui';
|
||||
import { Avatar, Dot } from './ui';
|
||||
import { go } from './util';
|
||||
import { Wizard } from './wizard/Wizard';
|
||||
|
||||
@@ -26,6 +29,9 @@ const TABS: { id: string; icon: string; label: string; el: () => ReactNode }[] =
|
||||
{ id: 'diag', icon: '🔬', label: '진단', el: () => <DiagTab /> },
|
||||
{ id: 'general', icon: '⚙️', label: '일반', el: () => <GeneralTab /> },
|
||||
];
|
||||
/** 관리자 · 최고 관리자에게만 보이는 탭 */
|
||||
const ADMIN_TAB = { id: 'admin', icon: '🛡️', label: '관리자', el: () => <AdminTab /> };
|
||||
const tabsFor = (role: string | null) => (isAdminRole(role as never) ? [...TABS, ADMIN_TAB] : TABS);
|
||||
|
||||
function useHash(): string {
|
||||
const [h, setH] = useState(location.hash);
|
||||
@@ -38,7 +44,7 @@ function useHash(): string {
|
||||
}
|
||||
|
||||
function Router() {
|
||||
const { settings } = useApp();
|
||||
const { settings, state } = useApp();
|
||||
const hash = useHash();
|
||||
const parts = hash.replace(/^#\/?/, '').split('/');
|
||||
|
||||
@@ -53,10 +59,11 @@ function Router() {
|
||||
}, [isWizard]);
|
||||
|
||||
if (isWizard) return <Wizard step={Math.max(1, Math.min(5, Number(parts[1]) || 1))} />;
|
||||
const tab = TABS.find((t) => t.id === parts[1]) ?? TABS[0]!;
|
||||
const tabs = tabsFor(state.account.role);
|
||||
const tab = tabs.find((t) => t.id === parts[1]) ?? tabs[0]!;
|
||||
return (
|
||||
<div className="app">
|
||||
<Nav current={tab.id} />
|
||||
<Nav current={tab.id} tabs={tabs} />
|
||||
<main className="content" key={tab.id}>
|
||||
{tab.el()}
|
||||
</main>
|
||||
@@ -64,8 +71,9 @@ function Router() {
|
||||
);
|
||||
}
|
||||
|
||||
function Nav({ current }: { current: string }) {
|
||||
function Nav({ current, tabs }: { current: string; tabs: typeof TABS }) {
|
||||
const { state } = useApp();
|
||||
const acc = state.account;
|
||||
const bot = state.bot.status;
|
||||
const botTone = bot === 'ready' ? 'ok' : bot === 'connecting' ? 'warn' : bot === 'error' ? 'err' : 'off';
|
||||
const botText = bot === 'ready' ? (state.bot.recording.active ? '녹음 중' : '정상') : bot === 'connecting' ? '연결 중' : bot === 'error' ? '오류' : '꺼짐';
|
||||
@@ -74,13 +82,21 @@ function Nav({ current }: { current: string }) {
|
||||
const relayText = r === 'online' ? '연결됨' : r === 'connecting' ? '연결 중' : r === 'error' ? '오류' : '미등록';
|
||||
return (
|
||||
<nav className="side">
|
||||
{TABS.map((t) => (
|
||||
{tabs.map((t) => (
|
||||
<a key={t.id} href={`#/settings/${t.id}`} className={`tab ${t.id === current ? 'on' : ''}`}>
|
||||
<span className="ic">{t.icon}</span>
|
||||
{t.label}
|
||||
</a>
|
||||
))}
|
||||
<div className="nav-status">
|
||||
{acc.user && (
|
||||
<a href="#/settings/general" className="nav-account" title={acc.offline ? '사이트 서버에 연결되지 않아 마지막 확인 결과로 쓰는 중' : acc.user.id}>
|
||||
<Avatar name={acc.user.name} src={acc.user.avatar} size={18} />
|
||||
{acc.user.name}
|
||||
{acc.role && <span className={`role ${acc.role}`}>{ROLE_LABEL[acc.role]}</span>}
|
||||
{acc.offline && <span className="t-warn">·오프라인</span>}
|
||||
</a>
|
||||
)}
|
||||
<div className="brand-mini">
|
||||
<img src={tray} alt="" />
|
||||
겜녹이 v{state.version}
|
||||
@@ -101,7 +117,9 @@ function Nav({ current }: { current: string }) {
|
||||
}
|
||||
|
||||
createRoot(document.getElementById('root')!).render(
|
||||
<AppProvider>
|
||||
<Router />
|
||||
</AppProvider>,
|
||||
<AuthGate>
|
||||
<AppProvider>
|
||||
<Router />
|
||||
</AppProvider>
|
||||
</AuthGate>,
|
||||
);
|
||||
|
||||
@@ -1,9 +1,10 @@
|
||||
// 브라우저 개발/스크린샷용 가짜 GvrApi. window.gvr 가 없을 때만 쓴다.
|
||||
// URL 옵션: ?first=1 (첫 실행 · 마법사), ?nogpu=1 (GPU 없음), ?empty=1 (봇 토큰 없음), ?dl=0.6 (다운로드 시작 위치 비율)
|
||||
import type { User } from '@gvr/shared';
|
||||
// ?login=signed_out|not_registered|error (로그인 화면), ?role=superadmin|admin|user (기본 superadmin)
|
||||
import type { AppRole, AppUserRow, User } from '@gvr/shared';
|
||||
import type { DiagItem } from '../core/diagnostics';
|
||||
import type { Settings } from '../core/settings';
|
||||
import type { AppState, DownloadProgress, FinetuneStatus, GvrApi, ModelsInfo } from '../main/api-types';
|
||||
import type { AppState, AuthView, DownloadProgress, FinetuneStatus, GvrApi, ModelsInfo } from '../main/api-types';
|
||||
import { MODEL_META } from './models-meta';
|
||||
import { deepMerge, sleep } from './util';
|
||||
|
||||
@@ -92,8 +93,38 @@ export function createMockGvr(): GvrApi {
|
||||
settings.site.deviceId = 'dev_8f2c';
|
||||
}
|
||||
|
||||
const role = (q.get('role') as AppRole) || 'superadmin';
|
||||
const me = { id: '293719842274541579', name: role === 'user' ? '민준' : '사금향', avatar: null };
|
||||
const login = q.get('login');
|
||||
const auth: AuthView = {
|
||||
status: login === 'signed_out' || login === 'not_registered' || login === 'error' ? login : 'ok',
|
||||
user: login === 'not_registered' ? { id: '987654321098765432', name: '모르는사람', avatar: null } : login ? null : me,
|
||||
role: login ? null : role,
|
||||
offline: false,
|
||||
error: login === 'error' ? '사이트 서버에 연결할 수 없습니다 (fetch failed)' : null,
|
||||
loginUrl: null,
|
||||
verifiedAt: login ? null : now,
|
||||
appReady: !login,
|
||||
appError: null,
|
||||
version: '1.2.0',
|
||||
serverUrl: 'https://gvr.tkrmagid.kr',
|
||||
};
|
||||
const authListeners = new Set<(s: AuthView) => void>();
|
||||
const emitAuth = () => authListeners.forEach((l) => l(structuredClone(auth)));
|
||||
let adminRows: AppUserRow[] = [
|
||||
{ id: '293719842274541579', name: '사금향', avatar: null, role: 'superadmin', fixed: true, addedBy: null, addedAt: null, lastSeenAt: now - 60000, lastVersion: '1.2.0' },
|
||||
{ id: '1352267557213573160', name: '두번째관리자', avatar: null, role: 'superadmin', fixed: true, addedBy: null, addedAt: null, lastSeenAt: now - 3 * 86400000, lastVersion: '1.2.0' },
|
||||
{ id: '401234567890123456', name: '서연', avatar: null, role: 'admin', fixed: false, addedBy: '293719842274541579', addedAt: now - 5 * 86400000, lastSeenAt: now - 2 * 3600000, lastVersion: '1.2.0' },
|
||||
{ id: '402345678901234567', name: '민준', avatar: null, role: 'user', fixed: false, addedBy: '293719842274541579', addedAt: now - 4 * 86400000, lastSeenAt: now - 20 * 60000, lastVersion: '1.2.0' },
|
||||
{ id: '403456789012345678', name: '지호', avatar: null, role: 'user', fixed: false, addedBy: '293719842274541579', addedAt: now - 86400000, lastSeenAt: null, lastVersion: null },
|
||||
];
|
||||
const adminCheck = (lvl: 'admin' | 'superadmin') => {
|
||||
if (lvl === 'superadmin' ? role !== 'superadmin' : role === 'user') throw new Error(lvl === 'superadmin' ? '유저 등록은 최고 관리자만 할 수 있습니다' : '관리자만 볼 수 있습니다');
|
||||
};
|
||||
|
||||
const state: AppState = {
|
||||
version: '1.0.0',
|
||||
account: { user: me, role, offline: false },
|
||||
version: '1.2.0',
|
||||
dataDir: 'D:\\겜녹이\\GVR-Data',
|
||||
portable: true,
|
||||
settings,
|
||||
@@ -213,6 +244,60 @@ export function createMockGvr(): GvrApi {
|
||||
}, 4000);
|
||||
|
||||
const api: GvrApi = {
|
||||
async authState() {
|
||||
await sleep(60);
|
||||
return structuredClone(auth);
|
||||
},
|
||||
onAuth(cb) {
|
||||
authListeners.add(cb);
|
||||
return () => authListeners.delete(cb);
|
||||
},
|
||||
async authLogin() {
|
||||
Object.assign(auth, { status: 'waiting', loginUrl: 'https://gvr.tkrmagid.kr/auth/app/start/mock', error: null });
|
||||
emitAuth();
|
||||
await sleep(2500);
|
||||
if (auth.status !== 'waiting') return structuredClone(auth);
|
||||
Object.assign(auth, { status: 'ok', user: me, role, loginUrl: null, appReady: true, verifiedAt: Date.now() });
|
||||
emitAuth();
|
||||
return structuredClone(auth);
|
||||
},
|
||||
async authCancel() {
|
||||
Object.assign(auth, { status: 'signed_out', loginUrl: null });
|
||||
emitAuth();
|
||||
},
|
||||
async authLogout() {
|
||||
Object.assign(auth, { status: 'signed_out', user: null, role: null, appReady: false, error: null });
|
||||
emitAuth();
|
||||
},
|
||||
async authRecheck() {
|
||||
await sleep(600);
|
||||
return structuredClone(auth);
|
||||
},
|
||||
async adminUsers() {
|
||||
await sleep(200);
|
||||
adminCheck('admin');
|
||||
return { users: structuredClone(adminRows) };
|
||||
},
|
||||
async adminAddUser(id, r) {
|
||||
await sleep(400);
|
||||
adminCheck('superadmin');
|
||||
if (!/^\d{17,20}$/.test(id.trim())) throw new Error('디스코드 아이디는 17~20자리 숫자입니다');
|
||||
if (adminRows.some((u) => u.id === id.trim())) adminRows = adminRows.map((u) => (u.id === id.trim() && !u.fixed ? { ...u, role: r } : u));
|
||||
else adminRows.push({ id: id.trim(), name: `새유저${adminRows.length}`, avatar: null, role: r, fixed: false, addedBy: me.id, addedAt: Date.now(), lastSeenAt: null, lastVersion: null });
|
||||
return { users: structuredClone(adminRows) };
|
||||
},
|
||||
async adminSetRole(id, r) {
|
||||
await sleep(200);
|
||||
adminCheck('superadmin');
|
||||
adminRows = adminRows.map((u) => (u.id === id && !u.fixed ? { ...u, role: r } : u));
|
||||
return { users: structuredClone(adminRows) };
|
||||
},
|
||||
async adminRemoveUser(id) {
|
||||
await sleep(200);
|
||||
adminCheck('superadmin');
|
||||
adminRows = adminRows.filter((u) => u.id !== id || u.fixed);
|
||||
return { users: structuredClone(adminRows) };
|
||||
},
|
||||
async getState() {
|
||||
await sleep(80);
|
||||
return structuredClone(state);
|
||||
|
||||
@@ -296,3 +296,25 @@ input[type='number'].input { flex: none; padding: 7px 8px; }
|
||||
.modal-bg { position: fixed; inset: 0; background: rgba(3, 8, 12, 0.66); display: flex; align-items: center; justify-content: center; z-index: 60; }
|
||||
.modal { width: 420px; background: var(--panel); border: 1px solid var(--line); border-radius: 14px; padding: 22px; box-shadow: 0 20px 60px rgba(0, 0, 0, 0.5); }
|
||||
.modal-text { font-size: 14px; line-height: 1.6; margin-bottom: 18px; white-space: pre-wrap; }
|
||||
|
||||
/* ---------- 로그인 · 관리자 ---------- */
|
||||
.admin-lock { border: 0; min-width: 0; padding: 0; margin: 0; }
|
||||
.admin-lock .locked { opacity: 0.5; pointer-events: none; }
|
||||
.lock-note { font-size: 12px; color: var(--gold); margin-bottom: 8px; }
|
||||
.login { height: 100%; display: flex; align-items: center; justify-content: center; padding: 24px; }
|
||||
.login-card { width: 440px; background: var(--panel); border: 1px solid var(--line); border-radius: 16px; padding: 28px 30px 22px; display: flex; flex-direction: column; gap: 14px; }
|
||||
.login-card .banner { width: 100%; border-radius: 10px; border: 1px solid var(--line); display: block; }
|
||||
.login-title { font-size: 20px; font-weight: 800; }
|
||||
.login-card .btn.discord { background: #5865f2; border-color: #5865f2; color: #fff; font-weight: 700; padding: 12px 16px; font-size: 14px; }
|
||||
.login-who { display: flex; align-items: center; gap: 10px; background: var(--field); border: 1px solid var(--line); border-radius: 10px; padding: 10px 12px; }
|
||||
.login-who .id { font-family: var(--font-mono); font-size: 12px; color: var(--muted); }
|
||||
.login-bad { color: #ff6b77; font-weight: 700; font-size: 15px; }
|
||||
.login-foot { display: flex; align-items: center; gap: 8px; font-size: 12px; color: var(--dim); border-top: 1px solid var(--line); padding-top: 12px; }
|
||||
.role { display: inline-block; font-size: 11px; padding: 2px 8px; border-radius: 6px; font-weight: 700; }
|
||||
.role.superadmin { background: rgba(255, 70, 85, 0.16); color: #ff8a94; }
|
||||
.role.admin { background: rgba(242, 178, 58, 0.16); color: var(--gold); }
|
||||
.role.user { background: rgba(20, 193, 183, 0.14); color: var(--mint); }
|
||||
.nav-account { display: flex; align-items: center; gap: 6px; margin-bottom: 4px; color: #b9c6d2; }
|
||||
.admin-list { list-style: none; display: flex; flex-direction: column; gap: 6px; font-size: 13px; }
|
||||
.admin-list li { display: flex; gap: 8px; align-items: baseline; }
|
||||
.admin-list li .muted { font-size: 12px; }
|
||||
|
||||
195
app/src/renderer/tabs/AdminTab.tsx
Normal file
195
app/src/renderer/tabs/AdminTab.tsx
Normal file
@@ -0,0 +1,195 @@
|
||||
// 관리자 탭: 유저 등록(최고 관리자만) · 등록 유저 목록 · 관리자 전용 기능 안내
|
||||
import { useState } from 'react';
|
||||
import type { AppUserRow } from '@gvr/shared';
|
||||
import { ROLE_LABEL } from '../../core/roles';
|
||||
import { gvr, useAction, useApp, useLoad } from '../store';
|
||||
import { Avatar, Btn, Err, Page, Section, Select, Spinner } from '../ui';
|
||||
import { fmtAgo, fmtDate } from '../util';
|
||||
|
||||
const ROLE_OPTIONS = [
|
||||
{ value: 'user' as const, label: '유저' },
|
||||
{ value: 'admin' as const, label: '관리자' },
|
||||
];
|
||||
|
||||
/** 일반 유저가 바꿀 수 없는 것 (core/roles.ts 와 같은 목록) */
|
||||
const ADMIN_FEATURES: { what: string; why: string; tab: string }[] = [
|
||||
{ what: '다른 봇으로 바꾸기 · 봇 토큰 입력', why: '겜녹이 봇 대신 다른 봇을 붙이는 설정', tab: 'discord' },
|
||||
{ what: '녹음 안내(TTS) 끄기 · 안내 문구 변경', why: '녹음되는 사람에게 알리는 장치', tab: 'discord' },
|
||||
{ what: '음성 보관 기간', why: '다른 사람 목소리를 얼마나 남길지 정하는 정책', tab: 'storage' },
|
||||
{ what: '사이트 서버 주소 · PC 이름 · 사이트 등록/해제', why: '모두가 보는 사이트에 연결되는 PC', tab: 'storage' },
|
||||
{ what: '학습 데이터 삭제', why: '되돌릴 수 없는 삭제', tab: 'storage' },
|
||||
{ what: '파인튜닝 (학습 · 되돌리기 · 자동 일정)', why: '인식 모델을 바꾸는 작업', tab: 'stt' },
|
||||
];
|
||||
|
||||
function AddUser({ onDone }: { onDone: (users: AppUserRow[]) => void }) {
|
||||
const { toast } = useApp();
|
||||
const [id, setId] = useState('');
|
||||
const [role, setRole] = useState<'user' | 'admin'>('user');
|
||||
const act = useAction();
|
||||
const valid = /^\d{17,20}$/.test(id.trim());
|
||||
const add = async () => {
|
||||
const r = await act.run(() => gvr.adminAddUser(id.trim(), role));
|
||||
if (r) {
|
||||
onDone(r.users);
|
||||
setId('');
|
||||
toast(`${r.users.find((u) => u.id === id.trim())?.name ?? id.trim()} 등록됨`);
|
||||
}
|
||||
};
|
||||
return (
|
||||
<>
|
||||
<div className="field">
|
||||
<input
|
||||
className={`input mono ${id && !valid ? 'bad' : ''}`}
|
||||
value={id}
|
||||
placeholder="디스코드 아이디 (숫자 17~20자리)"
|
||||
spellCheck={false}
|
||||
onChange={(e) => setId(e.target.value.replace(/\s/g, ''))}
|
||||
onKeyDown={(e) => e.key === 'Enter' && valid && void add()}
|
||||
/>
|
||||
<Select width={110} value={role} options={ROLE_OPTIONS} onChange={setRole} />
|
||||
<Btn primary disabled={!valid} busy={act.busy} onClick={add}>
|
||||
등록
|
||||
</Btn>
|
||||
</div>
|
||||
<div className="hint">디스코드 설정 → 고급 → 개발자 모드를 켠 뒤, 프로필을 오른쪽 클릭 → '사용자 ID 복사'로 아이디를 얻습니다. 등록되지 않은 사람이 로그인하면 화면에 아이디가 나오니 그것을 받아도 됩니다.</div>
|
||||
<Err>{act.error}</Err>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
function UserTable({ users, superAdmin, onChange }: { users: AppUserRow[]; superAdmin: boolean; onChange: (users: AppUserRow[]) => void }) {
|
||||
const { state, confirm, toast } = useApp();
|
||||
const act = useAction();
|
||||
const name = (id: string | null) => (id ? (users.find((u) => u.id === id)?.name ?? id) : '-');
|
||||
return (
|
||||
<>
|
||||
<div className="table-wrap" style={{ maxHeight: 460 }}>
|
||||
<table className="table">
|
||||
<thead>
|
||||
<tr>
|
||||
<th>계정</th>
|
||||
<th>역할</th>
|
||||
<th>마지막 접속</th>
|
||||
<th>등록</th>
|
||||
{superAdmin && <th />}
|
||||
</tr>
|
||||
</thead>
|
||||
<tbody>
|
||||
{users.map((u) => (
|
||||
<tr key={u.id}>
|
||||
<td>
|
||||
<div className="row gap">
|
||||
<Avatar name={u.name} src={u.avatar} size={24} />
|
||||
<div>
|
||||
<div>
|
||||
{u.name}
|
||||
{u.id === state.account.user?.id && <span className="muted small"> (나)</span>}
|
||||
</div>
|
||||
<div className="mono dim small">{u.id}</div>
|
||||
</div>
|
||||
</div>
|
||||
</td>
|
||||
<td>
|
||||
{superAdmin && !u.fixed ? (
|
||||
<Select
|
||||
width={100}
|
||||
value={u.role as 'user' | 'admin'}
|
||||
options={ROLE_OPTIONS}
|
||||
disabled={act.busy}
|
||||
onChange={async (r) => {
|
||||
const res = await act.run(() => gvr.adminSetRole(u.id, r));
|
||||
if (res) {
|
||||
onChange(res.users);
|
||||
toast(`${u.name} → ${ROLE_LABEL[r]}`);
|
||||
}
|
||||
}}
|
||||
/>
|
||||
) : (
|
||||
<span className={`role ${u.role}`}>{ROLE_LABEL[u.role]}</span>
|
||||
)}
|
||||
</td>
|
||||
<td className="small">
|
||||
{u.lastSeenAt ? (
|
||||
<span title={fmtDate(u.lastSeenAt)}>
|
||||
{fmtAgo(u.lastSeenAt)}
|
||||
{u.lastVersion && <span className="dim"> · v{u.lastVersion}</span>}
|
||||
</span>
|
||||
) : (
|
||||
<span className="dim">접속 기록 없음</span>
|
||||
)}
|
||||
</td>
|
||||
<td className="small muted">{u.fixed ? '고정' : `${name(u.addedBy)} · ${u.addedAt ? fmtDate(u.addedAt) : '-'}`}</td>
|
||||
{superAdmin && (
|
||||
<td className="r">
|
||||
{!u.fixed && (
|
||||
<Btn
|
||||
small
|
||||
danger
|
||||
disabled={act.busy}
|
||||
onClick={async () => {
|
||||
if (!(await confirm(`${u.name} (${u.id}) 등록을 해제할까요? 이 사람의 겜녹이는 다음 확인 때(최대 10분) 바로 잠깁니다.`, { ok: '등록 해제', danger: true }))) return;
|
||||
const res = await act.run(() => gvr.adminRemoveUser(u.id));
|
||||
if (res) {
|
||||
onChange(res.users);
|
||||
toast(`${u.name} 등록 해제`);
|
||||
}
|
||||
}}
|
||||
>
|
||||
해제
|
||||
</Btn>
|
||||
)}
|
||||
</td>
|
||||
)}
|
||||
</tr>
|
||||
))}
|
||||
</tbody>
|
||||
</table>
|
||||
</div>
|
||||
<Err>{act.error}</Err>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
export function AdminTab() {
|
||||
const { state } = useApp();
|
||||
const superAdmin = state.account.role === 'superadmin';
|
||||
const list = useLoad(() => gvr.adminUsers());
|
||||
const users = list.data?.users ?? [];
|
||||
const set = (u: AppUserRow[]) => list.setData({ users: u });
|
||||
return (
|
||||
<Page
|
||||
title="관리자"
|
||||
desc={
|
||||
<>
|
||||
겜녹이는 등록된 디스코드 계정으로 로그인해야 쓸 수 있습니다. 유저 등록 · 역할 변경은 <b>최고 관리자</b>만, 목록 보기와 관리자 전용 설정은 <b>관리자</b>도 할 수 있습니다.
|
||||
{state.account.offline && <span className="t-warn"> 지금은 사이트 서버에 연결되지 않아 목록을 불러오지 못할 수 있습니다.</span>}
|
||||
</>
|
||||
}
|
||||
>
|
||||
<Section title="유저 등록" sub="최고 관리자만">
|
||||
{superAdmin ? <AddUser onDone={set} /> : <div className="lock-note">🔒 유저 등록 · 역할 변경 · 등록 해제는 최고 관리자만 할 수 있습니다. 아래 목록은 볼 수 있습니다.</div>}
|
||||
</Section>
|
||||
<Section
|
||||
title={`등록된 계정 ${users.length ? `${users.length}명` : ''}`}
|
||||
right={
|
||||
<Btn small ghost onClick={list.reload}>
|
||||
새로고침
|
||||
</Btn>
|
||||
}
|
||||
>
|
||||
{list.loading && !list.data ? <Spinner /> : list.error ? <Err>{list.error}</Err> : <UserTable users={users} superAdmin={superAdmin} onChange={set} />}
|
||||
</Section>
|
||||
<Section title="관리자 전용 기능" sub="일반 유저 화면에서는 잠겨 있습니다">
|
||||
<ul className="admin-list">
|
||||
{ADMIN_FEATURES.map((f) => (
|
||||
<li key={f.what}>
|
||||
<span>🔒</span>
|
||||
<a href={`#/settings/${f.tab}`}>{f.what}</a>
|
||||
<span className="muted">· {f.why}</span>
|
||||
</li>
|
||||
))}
|
||||
</ul>
|
||||
</Section>
|
||||
</Page>
|
||||
);
|
||||
}
|
||||
@@ -1,7 +1,7 @@
|
||||
import { useEffect, useRef, useState } from 'react';
|
||||
import type { GvrApi } from '../../main/api-types';
|
||||
import { gvr, useAction, useApp, useLoad } from '../store';
|
||||
import { Avatar, Btn, DraftInput, Err, Line, Ok, Page, Section, Select, ToggleLine } from '../ui';
|
||||
import { AdminOnly, Avatar, Btn, DraftInput, Err, Line, Ok, Page, Section, Select, ToggleLine, useIsAdmin } from '../ui';
|
||||
import { errMsg, fmtClock, fmtDuration } from '../util';
|
||||
|
||||
type TestResult = Awaited<ReturnType<GvrApi['testBotToken']>>;
|
||||
@@ -15,6 +15,7 @@ export const VOICES = [
|
||||
/** 봇 선택(겜녹이 기본 봇 / 다른 봇) + 연결 테스트. 다른 봇은 토큰 입력 · 저장. 마법사에서는 테스트 성공 시 바로 저장한다. */
|
||||
export function BotTokenSection({ wizard, onResult }: { wizard?: boolean; onResult?: (r: TestResult) => void }) {
|
||||
const { state, settings, save, toast } = useApp();
|
||||
const admin = useIsAdmin();
|
||||
const mode = settings.discord.botMode;
|
||||
const custom = mode === 'custom';
|
||||
const [token, setToken] = useState('');
|
||||
@@ -108,16 +109,16 @@ export function BotTokenSection({ wizard, onResult }: { wizard?: boolean; onResu
|
||||
return (
|
||||
<Section title="봇 연결">
|
||||
<div className="radio">
|
||||
<button type="button" className={!custom ? 'on' : ''} disabled={saver.busy} onClick={() => switchMode('builtin')}>
|
||||
<button type="button" className={!custom ? 'on' : ''} disabled={saver.busy || (!admin && custom)} onClick={() => switchMode('builtin')}>
|
||||
<b>🤖 겜녹이 봇으로 진행 {!custom && '✓'}</b>
|
||||
<span className="muted">{state.builtinBot ? '기본값 · 토큰 입력 없이 바로 연결' : '이 빌드에는 겜녹이 봇이 들어 있지 않습니다'}</span>
|
||||
<span className="muted">{state.builtinBot ? '기본값 · 토큰 입력 없이 바로 연결' : '겜녹이 봇 토큰을 아직 받지 못했습니다 (사이트 서버 연결 확인)'}</span>
|
||||
</button>
|
||||
<button type="button" className={custom ? 'on' : ''} disabled={saver.busy} onClick={() => switchMode('custom')}>
|
||||
<button type="button" className={custom ? 'on' : ''} disabled={saver.busy || !admin} onClick={() => switchMode('custom')} title={admin ? undefined : '관리자만 바꿀 수 있습니다'}>
|
||||
<b>🔑 다른 봇으로 진행하기 {custom && '✓'}</b>
|
||||
<span className="muted">직접 만든 봇의 토큰을 넣어서 사용</span>
|
||||
<span className="muted">{admin ? '직접 만든 봇의 토큰을 넣어서 사용' : '🔒 관리자만 바꿀 수 있습니다'}</span>
|
||||
</button>
|
||||
</div>
|
||||
{custom && (
|
||||
{custom && admin && (
|
||||
<>
|
||||
<div className="lab">봇 토큰 (암호화 저장)</div>
|
||||
<div className="field">
|
||||
@@ -314,12 +315,16 @@ export function DiscordTab() {
|
||||
</div>
|
||||
</Section>
|
||||
<Section title="녹음 안내 (TTS 음성) · 개인정보">
|
||||
<ToggleLine label="봇이 음성채널에 들어가면 TTS로 녹음 사실 안내" on={d.ttsEnabled} onChange={(v) => save({ discord: { ttsEnabled: v } })} />
|
||||
<ToggleLine label="새 사람이 들어오면 다시 안내" on={d.ttsOnNewMember} disabled={!d.ttsEnabled} onChange={(v) => save({ discord: { ttsOnNewMember: v } })} />
|
||||
<Line label="안내 문구">
|
||||
<div className="tts-text">
|
||||
<DraftInput multiline value={d.ttsText} onCommit={(v) => save({ discord: { ttsText: v } })} />
|
||||
</div>
|
||||
<AdminOnly note="녹음 안내를 끄거나 문구를 바꾸는 것은 관리자만 할 수 있습니다">
|
||||
<ToggleLine label="봇이 음성채널에 들어가면 TTS로 녹음 사실 안내" on={d.ttsEnabled} onChange={(v) => save({ discord: { ttsEnabled: v } })} />
|
||||
<ToggleLine label="새 사람이 들어오면 다시 안내" on={d.ttsOnNewMember} disabled={!d.ttsEnabled} onChange={(v) => save({ discord: { ttsOnNewMember: v } })} />
|
||||
<Line label="안내 문구">
|
||||
<div className="tts-text">
|
||||
<DraftInput multiline value={d.ttsText} onCommit={(v) => save({ discord: { ttsText: v } })} />
|
||||
</div>
|
||||
</Line>
|
||||
</AdminOnly>
|
||||
<Line label="안내 미리듣기">
|
||||
<TtsPreview />
|
||||
</Line>
|
||||
<Line label="목소리">
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
import { ROLE_LABEL } from '../../core/roles';
|
||||
import icon from '../assets/icon.png';
|
||||
import { gvr, useAction, useApp, useLoad } from '../store';
|
||||
import { Btn, Err, Line, Page, Section, Spinner, Toggle, ToggleLine } from '../ui';
|
||||
import { Avatar, Btn, Err, Line, Page, Section, Spinner, Toggle, ToggleLine } from '../ui';
|
||||
|
||||
const SITE = 'https://gvr.tkrmagid.kr';
|
||||
|
||||
@@ -8,8 +9,33 @@ export function GeneralTab() {
|
||||
const { state, settings, save, confirm, toast } = useApp();
|
||||
const logs = useLoad(() => gvr.recentLogs());
|
||||
const auto = useAction();
|
||||
const acc = state.account;
|
||||
return (
|
||||
<Page title="일반">
|
||||
<Section title="계정">
|
||||
<div className="row gap">
|
||||
{acc.user && <Avatar name={acc.user.name} src={acc.user.avatar} size={32} />}
|
||||
<div className="grow">
|
||||
<div>
|
||||
{acc.user?.name ?? '-'} {acc.role && <span className={`role ${acc.role}`}>{ROLE_LABEL[acc.role]}</span>}
|
||||
</div>
|
||||
<div className="mono dim small">
|
||||
{acc.user?.id}
|
||||
{acc.offline && <span className="t-warn"> · 사이트 서버에 연결되지 않아 마지막 확인 결과로 사용 중</span>}
|
||||
</div>
|
||||
</div>
|
||||
<Btn
|
||||
onClick={async () => {
|
||||
if (await confirm('로그아웃할까요? 봇 · 녹음 · 사이트 연결이 멈추고, 다시 로그인해야 쓸 수 있습니다.', { ok: '로그아웃', danger: true })) await gvr.authLogout();
|
||||
}}
|
||||
>
|
||||
로그아웃
|
||||
</Btn>
|
||||
</div>
|
||||
<div className="hint" style={{ marginTop: 8 }}>
|
||||
디스코드 계정으로 로그인했습니다. 10분마다 등록 여부를 다시 확인하며, 등록이 해제되면 바로 잠깁니다. 사이트 서버에 연결되지 않으면 마지막 확인 뒤 3일까지는 그대로 쓸 수 있습니다.
|
||||
</div>
|
||||
</Section>
|
||||
<Section title="실행">
|
||||
<Line label="윈도우 시작 시 자동 실행" hint="사이트를 계속 열어 두려면 권장">
|
||||
<Toggle
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
import { useState } from 'react';
|
||||
import { gvr, useAction, useApp, useLoad } from '../store';
|
||||
import { Btn, DraftInput, Err, FolderRow, Line, NumInput, Ok, Page, Section, Spinner } from '../ui';
|
||||
import { AdminOnly, Btn, DraftInput, Err, FolderRow, Line, NumInput, Ok, Page, Section, Spinner, useIsAdmin } from '../ui';
|
||||
import { fmtBytes, fmtDate } from '../util';
|
||||
|
||||
/** 녹음 폴더 + 보관 기간 (마법사에서도 사용) */
|
||||
@@ -19,20 +19,24 @@ export function AudioStorage() {
|
||||
}}
|
||||
onReset={() => save({ storage: { audioDir: null } })}
|
||||
/>
|
||||
<Line label="음성 보관 기간" hint="지나면 음성 파일만 삭제, 텍스트 · 경기 기록은 보관">
|
||||
<NumInput value={st.retentionDays} min={1} max={365} width={70} suffix="일" onCommit={(n) => save({ storage: { retentionDays: Math.round(n) } })} />
|
||||
</Line>
|
||||
<AdminOnly note="음성 보관 기간은 관리자만 바꿀 수 있습니다">
|
||||
<Line label="음성 보관 기간" hint="지나면 음성 파일만 삭제, 텍스트 · 경기 기록은 보관">
|
||||
<NumInput value={st.retentionDays} min={1} max={365} width={70} suffix="일" onCommit={(n) => save({ storage: { retentionDays: Math.round(n) } })} />
|
||||
</Line>
|
||||
</AdminOnly>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
/** 사이트 등록 코드 입력 (마법사에서도 사용) */
|
||||
export function RegisterDevice() {
|
||||
export function RegisterDevice({ quiet }: { quiet?: boolean }) {
|
||||
const { state, settings, toast } = useApp();
|
||||
const [code, setCode] = useState('');
|
||||
const act = useAction();
|
||||
const admin = useIsAdmin();
|
||||
const registered = !!settings.site.deviceId && state.secrets.deviceKey;
|
||||
if (registered) return null;
|
||||
if (!admin) return quiet ? null : <div className="lock-note">🔒 사이트 등록은 관리자만 할 수 있습니다. 필요하면 관리자에게 요청해 주세요.</div>;
|
||||
return (
|
||||
<>
|
||||
<div className="field">
|
||||
@@ -127,6 +131,7 @@ function Usage() {
|
||||
|
||||
export function StorageTab() {
|
||||
const { state, settings, save, confirm, toast } = useApp();
|
||||
const admin = useIsAdmin();
|
||||
const site = settings.site;
|
||||
const relay = state.relay;
|
||||
const registered = !!site.deviceId && state.secrets.deviceKey;
|
||||
@@ -141,18 +146,20 @@ export function StorageTab() {
|
||||
</Section>
|
||||
<Usage />
|
||||
<Section title="사이트 서버" sub="이 PC가 사이트로 연결을 열어 둡니다 (포트 개방 불필요)">
|
||||
<Line label="서버 주소">
|
||||
<DraftInput mono value={site.serverUrl} onCommit={(v) => save({ site: { serverUrl: v.trim() } })} className="w320" />
|
||||
</Line>
|
||||
<Line label="이 PC 이름" hint="사이트에 보이는 이름">
|
||||
<DraftInput value={site.deviceName} onCommit={(v) => save({ site: { deviceName: v.trim() || 'GAME-PC' } })} className="w320" />
|
||||
</Line>
|
||||
<AdminOnly note="사이트 서버 설정은 관리자만 바꿀 수 있습니다">
|
||||
<Line label="서버 주소">
|
||||
<DraftInput mono value={site.serverUrl} onCommit={(v) => save({ site: { serverUrl: v.trim() } })} className="w320" />
|
||||
</Line>
|
||||
<Line label="이 PC 이름" hint="사이트에 보이는 이름">
|
||||
<DraftInput value={site.deviceName} onCommit={(v) => save({ site: { deviceName: v.trim() || 'GAME-PC' } })} className="w320" />
|
||||
</Line>
|
||||
</AdminOnly>
|
||||
<div className={`relay ${relay.state}`}>
|
||||
<span className={`dot ${relay.state === 'online' ? 'ok' : relay.state === 'connecting' ? 'warn' : relay.state === 'error' ? 'err' : 'off'}`} />
|
||||
<b>{relayText}</b>
|
||||
{registered && <span className="muted mono small">기기 ID {site.deviceId}</span>}
|
||||
<span className="grow" />
|
||||
{registered && (
|
||||
{registered && admin && (
|
||||
<Btn
|
||||
small
|
||||
busy={unreg.busy}
|
||||
@@ -165,22 +172,24 @@ export function StorageTab() {
|
||||
</Btn>
|
||||
)}
|
||||
</div>
|
||||
<RegisterDevice />
|
||||
<RegisterDevice quiet />
|
||||
<Err>{unreg.error}</Err>
|
||||
</Section>
|
||||
<Section title="학습 데이터">
|
||||
<Line label="학습 데이터 전체 삭제" hint="교정한 문장의 음성 조각과 합성 음성을 지웁니다. 대화 기록과 모델은 남습니다">
|
||||
<Btn
|
||||
danger
|
||||
busy={clear.busy}
|
||||
onClick={async () => {
|
||||
if (!(await confirm('학습 데이터를 모두 지울까요? 되돌릴 수 없습니다.', { ok: '전체 삭제', danger: true }))) return;
|
||||
if (await clear.runOk(() => gvr.clearTrainingData())) toast('학습 데이터 삭제됨');
|
||||
}}
|
||||
>
|
||||
전체 삭제
|
||||
</Btn>
|
||||
</Line>
|
||||
<AdminOnly>
|
||||
<Line label="학습 데이터 전체 삭제" hint="교정한 문장의 음성 조각과 합성 음성을 지웁니다. 대화 기록과 모델은 남습니다">
|
||||
<Btn
|
||||
danger
|
||||
busy={clear.busy}
|
||||
onClick={async () => {
|
||||
if (!(await confirm('학습 데이터를 모두 지울까요? 되돌릴 수 없습니다.', { ok: '전체 삭제', danger: true }))) return;
|
||||
if (await clear.runOk(() => gvr.clearTrainingData())) toast('학습 데이터 삭제됨');
|
||||
}}
|
||||
>
|
||||
전체 삭제
|
||||
</Btn>
|
||||
</Line>
|
||||
</AdminOnly>
|
||||
<Err>{clear.error}</Err>
|
||||
</Section>
|
||||
</Page>
|
||||
|
||||
@@ -3,7 +3,7 @@ import type { FinetuneStatus } from '../../main/api-types';
|
||||
import { CARD_MODELS, COMPUTE_TYPES } from '../models-meta';
|
||||
import { DownloadRow, GpuCard, ModelCard, useSttData, type ModelRole } from '../stt-parts';
|
||||
import { gvr, useAction, useApp } from '../store';
|
||||
import { Bar, Btn, Err, FolderRow, Line, NumInput, Page, Section, Select, Spinner, ToggleLine } from '../ui';
|
||||
import { AdminOnly, Bar, Btn, Err, FolderRow, Line, NumInput, Page, Section, Select, Spinner, ToggleLine } from '../ui';
|
||||
import { fmtDate, fmtMb } from '../util';
|
||||
|
||||
const SLOT_TEXT: Record<string, string> = { empty: '대기', loading: '불러오는 중', loaded: '사용 중', missing: '파일 없음', error: '오류' };
|
||||
@@ -77,38 +77,40 @@ function Finetune() {
|
||||
<Bar pct={st.step !== null && st.total ? (st.step / st.total) * 100 : 5} color="linear-gradient(90deg,#14c1b7,#5fe0d8)" />
|
||||
</div>
|
||||
)}
|
||||
<div className="row wrap gap">
|
||||
{!st.toolsInstalled && (
|
||||
<Btn primary busy={st.installing} onClick={() => call(() => gvr.finetuneInstall(), '학습 도구 설치 시작')}>
|
||||
학습 도구 설치 (약 3GB)
|
||||
<AdminOnly note="파인튜닝은 관리자만 할 수 있습니다">
|
||||
<div className="row wrap gap">
|
||||
{!st.toolsInstalled && (
|
||||
<Btn primary busy={st.installing} onClick={() => call(() => gvr.finetuneInstall(), '학습 도구 설치 시작')}>
|
||||
학습 도구 설치 (약 3GB)
|
||||
</Btn>
|
||||
)}
|
||||
<Btn primary={st.toolsInstalled} disabled={!st.toolsInstalled || st.running} onClick={() => call(() => gvr.finetuneStart(), '학습 시작')}>
|
||||
지금 학습
|
||||
</Btn>
|
||||
)}
|
||||
<Btn primary={st.toolsInstalled} disabled={!st.toolsInstalled || st.running} onClick={() => call(() => gvr.finetuneStart(), '학습 시작')}>
|
||||
지금 학습
|
||||
</Btn>
|
||||
<Btn disabled={!st.running} onClick={() => call(() => gvr.finetuneStop(), '학습 중지')}>
|
||||
중지
|
||||
</Btn>
|
||||
<Btn
|
||||
disabled={!st.previousModel || st.running}
|
||||
onClick={async () => {
|
||||
if (await confirm(`이전 모델(${st.previousModel})로 되돌릴까요?`, { ok: '되돌리기' })) await call(() => gvr.finetuneRollback(), '이전 모델로 되돌림');
|
||||
}}
|
||||
>
|
||||
이전 모델로 되돌리기
|
||||
</Btn>
|
||||
<span className="grow" />
|
||||
<span className="muted small">자동 학습</span>
|
||||
<Select
|
||||
width={190}
|
||||
value={settings.finetune.schedule}
|
||||
options={[
|
||||
{ value: 'off', label: '끔' },
|
||||
{ value: 'nightly', label: '매일 새벽 자동' },
|
||||
]}
|
||||
onChange={(v) => save({ finetune: { schedule: v } })}
|
||||
/>
|
||||
</div>
|
||||
<Btn disabled={!st.running} onClick={() => call(() => gvr.finetuneStop(), '학습 중지')}>
|
||||
중지
|
||||
</Btn>
|
||||
<Btn
|
||||
disabled={!st.previousModel || st.running}
|
||||
onClick={async () => {
|
||||
if (await confirm(`이전 모델(${st.previousModel})로 되돌릴까요?`, { ok: '되돌리기' })) await call(() => gvr.finetuneRollback(), '이전 모델로 되돌림');
|
||||
}}
|
||||
>
|
||||
이전 모델로 되돌리기
|
||||
</Btn>
|
||||
<span className="grow" />
|
||||
<span className="muted small">자동 학습</span>
|
||||
<Select
|
||||
width={190}
|
||||
value={settings.finetune.schedule}
|
||||
options={[
|
||||
{ value: 'off', label: '끔' },
|
||||
{ value: 'nightly', label: '매일 새벽 자동' },
|
||||
]}
|
||||
onChange={(v) => save({ finetune: { schedule: v } })}
|
||||
/>
|
||||
</div>
|
||||
</AdminOnly>
|
||||
<Err>{act.error}</Err>
|
||||
<div className="hint" style={{ marginTop: 8 }}>
|
||||
게임이 켜지면 학습을 바로 멈춥니다. 학습 전후 같은 검증 문장의 오류율(CER)이 좋아졌을 때만 새 모델로 바꿉니다.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// 공용 UI 조각
|
||||
import { useState, type ReactNode } from 'react';
|
||||
import { useDraft } from './store';
|
||||
import { isAdminRole } from '../core/roles';
|
||||
import { useApp, useDraft } from './store';
|
||||
import { errMsg } from './util';
|
||||
|
||||
export function Page({ title, desc, children }: { title: string; desc?: ReactNode; children: ReactNode }) {
|
||||
@@ -226,3 +227,20 @@ export function FolderRow({ path, placeholder, onChoose, onReset }: { path: stri
|
||||
</div>
|
||||
);
|
||||
}
|
||||
|
||||
/** 로그인한 계정이 관리자(최고 관리자 포함)인지 */
|
||||
export function useIsAdmin(): boolean {
|
||||
return isAdminRole(useApp().state.account.role);
|
||||
}
|
||||
|
||||
/** 관리자 전용 설정: 일반 유저에게는 잠근 채로 보여 준다 (실제 차단은 메인 프로세스가 한다) */
|
||||
export function AdminOnly({ children, note = '관리자만 바꿀 수 있습니다' }: { children: ReactNode; note?: ReactNode }) {
|
||||
const admin = useIsAdmin();
|
||||
if (admin) return <>{children}</>;
|
||||
return (
|
||||
<fieldset className="admin-lock" disabled>
|
||||
{note && <div className="lock-note">🔒 {note}</div>}
|
||||
<div className="locked">{children}</div>
|
||||
</fieldset>
|
||||
);
|
||||
}
|
||||
|
||||
@@ -13,8 +13,19 @@ export function deepMerge<T>(base: T, over: unknown): T {
|
||||
}
|
||||
|
||||
export function errMsg(e: unknown): string {
|
||||
if (e instanceof Error) return e.message;
|
||||
return String(e);
|
||||
const m = e instanceof Error ? e.message : String(e);
|
||||
// IPC 오류는 "Error invoking remote method 'gvr:x': Error: 메시지" 로 온다
|
||||
return m.replace(/^Error invoking remote method '[^']+': (?:\w*Error: )?/, '');
|
||||
}
|
||||
|
||||
/** "3분 전" · "2시간 전" · "4일 전" */
|
||||
export function fmtAgo(ts: number | null | undefined): string {
|
||||
if (!ts) return '-';
|
||||
const s = Math.max(0, (Date.now() - ts) / 1000);
|
||||
if (s < 60) return '방금';
|
||||
if (s < 3600) return `${Math.floor(s / 60)}분 전`;
|
||||
if (s < 86400) return `${Math.floor(s / 3600)}시간 전`;
|
||||
return `${Math.floor(s / 86400)}일 전`;
|
||||
}
|
||||
|
||||
/** MB → "1.6GB" / "464MB" */
|
||||
|
||||
156
app/test/auth.test.ts
Normal file
156
app/test/auth.test.ts
Normal file
@@ -0,0 +1,156 @@
|
||||
// 앱 로그인(core/auth.ts) ↔ 실제 사이트 서버 코드(site/server) 통합 테스트. 디스코드만 가짜.
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import http from 'node:http';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { buildServer } from '../../site/server/src/app.ts';
|
||||
import { AppAuth } from '../src/core/auth.ts';
|
||||
import { adminOnlyPaths } from '../src/core/roles.ts';
|
||||
import { SettingsStore } from '../src/core/settings.ts';
|
||||
|
||||
const SUPER = '1352267557213573160';
|
||||
const FRIEND = '111111111111111111';
|
||||
const STRANGER = '222222222222222222';
|
||||
const BOT = 'MTExMTExMTExMTExMTExMTEx.FAKE00.server-delivered-token-xxxxxxxx';
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-auth-'));
|
||||
delete process.env.GVR_BOT_TOKEN;
|
||||
|
||||
async function fakeDiscord() {
|
||||
const names: Record<string, string> = { [SUPER]: '관리자', [FRIEND]: '친구', [STRANGER]: '모르는사람' };
|
||||
const srv = http.createServer((req, res) => {
|
||||
const u = new URL(req.url!, 'http://x');
|
||||
res.setHeader('content-type', 'application/json');
|
||||
if (u.pathname === '/oauth2/token') {
|
||||
let b = '';
|
||||
req.on('data', (c) => (b += c));
|
||||
req.on('end', () => res.end(JSON.stringify({ access_token: new URLSearchParams(b).get('code') })));
|
||||
return;
|
||||
}
|
||||
if (u.pathname === '/users/@me') {
|
||||
const id = String(req.headers.authorization).replace('Bearer ', '');
|
||||
return res.end(JSON.stringify({ id, username: names[id], global_name: names[id], avatar: null }));
|
||||
}
|
||||
const m = /^\/users\/(\d+)$/.exec(u.pathname);
|
||||
if (m && names[m[1]!]) return res.end(JSON.stringify({ id: m[1], username: names[m[1]!], global_name: names[m[1]!], avatar: null }));
|
||||
res.statusCode = 404;
|
||||
res.end('{}');
|
||||
});
|
||||
await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
|
||||
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
|
||||
}
|
||||
|
||||
async function stack() {
|
||||
const dc = await fakeDiscord();
|
||||
const { app } = await buildServer({
|
||||
port: 0, host: '127.0.0.1', publicUrl: 'http://placeholder', clientId: 'cid', clientSecret: 's', botToken: BOT,
|
||||
allowedGuilds: [], owners: [SUPER], superAdmins: [SUPER], sessionSecret: 'x'.repeat(32), dataDir: tmp(), webDir: '/nonexistent',
|
||||
version: 'test', discordApi: dc.url, assetUpstream: {},
|
||||
});
|
||||
await app.listen({ host: '127.0.0.1', port: 0 });
|
||||
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
|
||||
/** 브라우저 흉내: 로그인 주소 → 디스코드(가짜) → 콜백. who = 디스코드에서 로그인한 계정 */
|
||||
const browser = (who: string) => async (url: string) => {
|
||||
const start = await fetch(url.replace('http://placeholder', base), { redirect: 'manual' });
|
||||
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
|
||||
const cookie = start.headers.getSetCookie()[0]!.split(';')[0]!;
|
||||
await fetch(`${base}/auth/discord/callback?code=${who}&state=${encodeURIComponent(state)}`, { headers: { cookie }, redirect: 'manual' });
|
||||
};
|
||||
const settingsFor = (dir = tmp()) => {
|
||||
const s = new SettingsStore(dir);
|
||||
s.update({ site: { serverUrl: base } });
|
||||
return s;
|
||||
};
|
||||
return { base, browser, settingsFor, close: async () => (await app.close(), dc.close()) };
|
||||
}
|
||||
|
||||
test('앱 로그인: 등록된 아이디만 열리고, 겜녹이 봇 토큰은 로그인 후 서버에서 받는다', async () => {
|
||||
const s = await stack();
|
||||
try {
|
||||
// 로그인 전: 토큰 없음 → 로그인 화면
|
||||
const st = s.settingsFor();
|
||||
const auth = new AppAuth(st, { version: '1.2.0', openUrl: s.browser(STRANGER), pollMs: 20 });
|
||||
assert.equal((await auth.check()).status, 'signed_out');
|
||||
assert.equal(st.activeBotToken(), null);
|
||||
|
||||
// 미등록 아이디 → 등록되지 않은 아이디, 토큰 없음
|
||||
const r1 = await auth.login();
|
||||
assert.equal(r1.status, 'not_registered');
|
||||
assert.equal(r1.user?.id, STRANGER);
|
||||
assert.equal(st.hasSecret('appToken'), false);
|
||||
assert.equal(st.activeBotToken(), null);
|
||||
|
||||
// 최고 관리자 로그인 → 봇 토큰 받음
|
||||
const adminSt = s.settingsFor();
|
||||
const admin = new AppAuth(adminSt, { version: '1.2.0', openUrl: s.browser(SUPER), pollMs: 20 });
|
||||
const r2 = await admin.login();
|
||||
assert.equal(r2.status, 'ok');
|
||||
assert.equal(r2.role, 'superadmin');
|
||||
assert.equal(adminSt.activeBotToken(), BOT);
|
||||
|
||||
// 최고 관리자가 친구 등록 (관리자 화면 API)
|
||||
const list = await admin.adminAddUser(FRIEND, 'user');
|
||||
assert.ok(list.users.some((u) => u.id === FRIEND && u.role === 'user'));
|
||||
|
||||
// 친구 로그인 → 일반 유저
|
||||
const dir = tmp();
|
||||
const frSt = s.settingsFor(dir);
|
||||
const fr = new AppAuth(frSt, { version: '1.2.0', openUrl: s.browser(FRIEND), pollMs: 20 });
|
||||
const r3 = await fr.login();
|
||||
assert.equal(r3.status, 'ok');
|
||||
assert.equal(r3.role, 'user');
|
||||
assert.equal(frSt.activeBotToken(), BOT);
|
||||
await assert.rejects(fr.adminAddUser(STRANGER, 'user'), /최고 관리자만/);
|
||||
await assert.rejects(fr.adminUsers(), /관리자만/);
|
||||
// 다시 켜도 (새 SettingsStore) 로그인 유지
|
||||
assert.equal((await new AppAuth(s.settingsFor(dir), { version: '1.2.0', openUrl: () => undefined }).check()).status, 'ok');
|
||||
// 토큰 · 봇 토큰은 평문 settings.json 에 없다
|
||||
assert.ok(!fs.readFileSync(path.join(dir, 'settings.json'), 'utf8').includes(BOT));
|
||||
|
||||
// 등록 해제 → 다음 확인에서 잠기고 받아 둔 봇 토큰도 지운다
|
||||
await admin.adminRemoveUser(FRIEND);
|
||||
const r4 = await fr.check();
|
||||
assert.equal(r4.status, 'not_registered');
|
||||
assert.equal(r4.user?.id, FRIEND);
|
||||
assert.equal(frSt.activeBotToken(), null);
|
||||
assert.equal(frSt.hasSecret('appToken'), false);
|
||||
|
||||
// 로그아웃 → 토큰 · 봇 토큰 삭제, 서버에서도 무효
|
||||
await admin.logout();
|
||||
assert.equal(admin.state.status, 'signed_out');
|
||||
assert.equal(adminSt.activeBotToken(), null);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('앱 로그인: 서버에 못 붙으면 마지막 확인 후 유예 기간까지만 쓴다', async () => {
|
||||
const s = await stack();
|
||||
const dir = tmp();
|
||||
const st = s.settingsFor(dir);
|
||||
const auth = new AppAuth(st, { version: '1.2.0', openUrl: s.browser(SUPER), pollMs: 20 });
|
||||
assert.equal((await auth.login()).status, 'ok');
|
||||
await s.close();
|
||||
// 서버 꺼짐 → 마지막 확인이 방금이라 오프라인으로 계속
|
||||
const r = await auth.check();
|
||||
assert.equal(r.status, 'ok');
|
||||
assert.equal(r.offline, true);
|
||||
assert.equal(st.activeBotToken(), BOT);
|
||||
// 유예 기간이 지나면 막힌다 (토큰은 남겨 두어 서버가 돌아오면 다시 확인)
|
||||
const late = new AppAuth(st, { version: '1.2.0', openUrl: () => undefined, offlineGraceMs: 0 });
|
||||
const r2 = await late.check();
|
||||
assert.equal(r2.status, 'error');
|
||||
assert.match(r2.error!, /연결할 수 없습니다/);
|
||||
assert.equal(st.hasSecret('appToken'), true);
|
||||
});
|
||||
|
||||
test('관리자 전용 설정: 일반 유저가 바꾸면 안 되는 경로만 골라낸다', () => {
|
||||
assert.deepEqual(adminOnlyPaths({ discord: { botMode: 'custom' } }), ['discord.botMode']);
|
||||
assert.deepEqual(adminOnlyPaths({ discord: { guildId: 'g', ttsVoice: 'x' }, stt: { realtimeModel: 'small' } }), []);
|
||||
assert.deepEqual(adminOnlyPaths({ discord: { ttsEnabled: false, ttsText: 'x', ttsVoice: 'y' } }), ['discord.ttsEnabled', 'discord.ttsText']);
|
||||
assert.deepEqual(adminOnlyPaths({ storage: { retentionDays: 30, audioDir: 'D:/a' } }), ['storage.retentionDays']);
|
||||
assert.deepEqual(adminOnlyPaths({ site: { deviceName: 'x' } }), ['site']);
|
||||
assert.deepEqual(adminOnlyPaths({ finetune: { schedule: 'nightly' } }), ['finetune']);
|
||||
assert.deepEqual(adminOnlyPaths({ firstRunDone: true, general: { sfx: false } }), []);
|
||||
});
|
||||
@@ -3,7 +3,6 @@ import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { builtinBotToken, decodeBuiltinToken, encodeBuiltinToken } from '../src/core/builtin-bot.ts';
|
||||
import { SettingsStore } from '../src/core/settings.ts';
|
||||
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-bot-'));
|
||||
@@ -11,25 +10,29 @@ const BUILTIN = 'MTExMTExMTExMTExMTExMTEx.FAKE00.builtin-token-for-tests-only-xx
|
||||
const OTHER = 'OTE4MTIzMzQ4NzIxMDA4NzAw.FAKE11.other-bot-token-for-tests-only-yyyy';
|
||||
delete process.env.GVR_BOT_TOKEN;
|
||||
|
||||
test('기본 봇 토큰: 감춘 값은 평문을 담지 않고 되돌리면 원래 토큰', () => {
|
||||
const blob = encodeBuiltinToken(BUILTIN);
|
||||
assert.ok(!blob.includes(BUILTIN));
|
||||
for (const part of BUILTIN.split('.')) assert.ok(!blob.includes(part), part);
|
||||
assert.equal(decodeBuiltinToken(blob), BUILTIN);
|
||||
// 개발 실행(빌드 상수 없음)에서는 기본 봇이 없다
|
||||
assert.equal(builtinBotToken(), null);
|
||||
/** 로그인해서 서버가 겜녹이 봇 토큰을 내려준 상태 */
|
||||
const loggedIn = (dir = tmp()) => {
|
||||
const s = new SettingsStore(dir);
|
||||
s.setSecret('builtinBotToken', BUILTIN);
|
||||
return s;
|
||||
};
|
||||
|
||||
test('로그인 전: 겜녹이 봇 토큰이 없다 (exe 에 들어 있지 않다)', () => {
|
||||
const s = new SettingsStore(tmp());
|
||||
assert.equal(s.get().discord.botMode, 'builtin');
|
||||
assert.equal(s.hasBuiltinBot, false);
|
||||
assert.equal(s.activeBotToken(), null);
|
||||
});
|
||||
|
||||
test('새 설치: 겜녹이 봇이 기본이고 토큰 입력 없이 기본 토큰을 쓴다', () => {
|
||||
const s = new SettingsStore(tmp(), undefined, { builtinBotToken: BUILTIN });
|
||||
assert.equal(s.get().discord.botMode, 'builtin');
|
||||
test('로그인 후: 겜녹이 봇이 기본이고 서버에서 받은 토큰을 쓴다', () => {
|
||||
const s = loggedIn();
|
||||
assert.equal(s.hasBuiltinBot, true);
|
||||
assert.equal(s.activeBotToken(), BUILTIN);
|
||||
});
|
||||
|
||||
test('다른 봇으로 진행하기: 넣은 토큰을 쓰고, 다시 겜녹이 봇으로 오가도 각자 유지된다', () => {
|
||||
const dir = tmp();
|
||||
const s = new SettingsStore(dir, undefined, { builtinBotToken: BUILTIN });
|
||||
const s = loggedIn(dir);
|
||||
s.update({ discord: { botMode: 'custom' } });
|
||||
assert.equal(s.activeBotToken(), null, '다른 봇인데 토큰이 아직 없으면 로그인하지 않는다');
|
||||
s.setSecret('botToken', OTHER);
|
||||
@@ -41,40 +44,30 @@ test('다른 봇으로 진행하기: 넣은 토큰을 쓰고, 다시 겜녹이
|
||||
assert.equal(s.activeBotToken(), OTHER, '저장한 다른 봇 토큰은 지워지지 않는다');
|
||||
|
||||
// 다시 켜도 모드·토큰이 남는다
|
||||
const again = new SettingsStore(dir, undefined, { builtinBotToken: BUILTIN });
|
||||
const again = new SettingsStore(dir);
|
||||
assert.equal(again.get().discord.botMode, 'custom');
|
||||
assert.equal(again.activeBotToken(), OTHER);
|
||||
// 저장 파일에 기본 봇 토큰은 들어가지 않는다
|
||||
for (const f of fs.readdirSync(dir)) assert.ok(!fs.readFileSync(path.join(dir, f), 'utf8').includes(BUILTIN), f);
|
||||
// 평문 설정 파일(settings.json)에는 토큰이 들어가지 않는다
|
||||
assert.ok(!fs.readFileSync(path.join(dir, 'settings.json'), 'utf8').includes(BUILTIN));
|
||||
});
|
||||
|
||||
test('v1.0.0 에서 직접 토큰을 넣어 쓰던 설치는 다른 봇 모드로 이어진다', () => {
|
||||
const dir = tmp();
|
||||
const old = new SettingsStore(dir, undefined, { builtinBotToken: null });
|
||||
const old = new SettingsStore(dir);
|
||||
old.setSecret('botToken', OTHER);
|
||||
const saved = JSON.parse(JSON.stringify(old.get()));
|
||||
delete saved.discord.botMode;
|
||||
fs.writeFileSync(path.join(dir, 'settings.json'), JSON.stringify(saved));
|
||||
|
||||
const s = new SettingsStore(dir, undefined, { builtinBotToken: BUILTIN });
|
||||
const s = new SettingsStore(dir);
|
||||
assert.equal(s.get().discord.botMode, 'custom');
|
||||
assert.equal(s.activeBotToken(), OTHER);
|
||||
});
|
||||
|
||||
test('기본 봇이 없는 빌드: 겜녹이 봇 모드면 토큰 없음, 다른 봇은 그대로 동작', () => {
|
||||
const s = new SettingsStore(tmp(), undefined, { builtinBotToken: null });
|
||||
assert.equal(s.hasBuiltinBot, false);
|
||||
assert.equal(s.activeBotToken(), null);
|
||||
s.update({ discord: { botMode: 'custom' } });
|
||||
s.setSecret('botToken', OTHER);
|
||||
assert.equal(s.activeBotToken(), OTHER);
|
||||
});
|
||||
|
||||
test('개발용 GVR_BOT_TOKEN 은 모드와 상관없이 우선한다', () => {
|
||||
process.env.GVR_BOT_TOKEN = OTHER;
|
||||
try {
|
||||
const s = new SettingsStore(tmp(), undefined, { builtinBotToken: BUILTIN });
|
||||
assert.equal(s.activeBotToken(), OTHER);
|
||||
assert.equal(loggedIn().activeBotToken(), OTHER);
|
||||
} finally {
|
||||
delete process.env.GVR_BOT_TOKEN;
|
||||
}
|
||||
|
||||
@@ -94,6 +94,7 @@ tools/ 사전 생성기, 테스트 도구(목 Riot 서버, 음성
|
||||
GVR-Data/
|
||||
settings.json 일반 설정 (평문)
|
||||
secrets.bin 비밀값 (Windows: Electron safeStorage = DPAPI, 헤드리스: 0600 평문 JSON)
|
||||
앱 로그인 토큰 · 서버가 내려준 겜녹이 봇 토큰 · 마지막 로그인 확인(오프라인 3일 유예용) 포함
|
||||
gvr.sqlite 기록 DB
|
||||
audio/YYYY-MM-DD/<utteranceId>.ogg
|
||||
training/<sampleId>.ogg 교정한 문장의 음성 조각 (자동 삭제 제외, A3)
|
||||
@@ -208,4 +209,11 @@ type TimelineItem =
|
||||
| `/api/*` | 로그인 + 기기 온라인이면 앱으로 중계, 오프라인이면 `503 {error:'device_offline'}` |
|
||||
| `WS /ws` | 브라우저용. `{type:'status',data}` + 5장 이벤트 |
|
||||
| `POST /admin/registration-code` | 관리자 전용 → `{code, expiresAt}` |
|
||||
| `POST /auth/app/begin` | 앱 로그인 시작 → `{id, secret, url, expiresAt}` (url 을 브라우저로 연다, 10분 유효) |
|
||||
| `GET /auth/app/start/:id` | 브라우저: state 쿠키(`app.<id>.<nonce>`) → 디스코드 OAuth → 같은 `/auth/discord/callback` |
|
||||
| `POST /auth/app/poll` | `{id, secret}` → `{state:'pending'}` · `{state:'ok', token, user, role}` · `{state:'not_registered', user}` (결과는 한 번만) |
|
||||
| `GET /app/me` | `Authorization: Bearer <앱 토큰>` → `{user, role, botToken, serverTime}`. 미등록 403 `not_registered`, 토큰 무효 401. 겜녹이 봇 토큰은 여기서만 내려준다 |
|
||||
| `POST /auth/app/logout` | 앱 토큰 무효화 |
|
||||
| `GET /app/admin/users` | 관리자 이상 → `{users: AppUserRow[]}` (최고 관리자 고정 행 포함) |
|
||||
| `POST /app/admin/users` · `PATCH`/`DELETE /app/admin/users/:id` | 최고 관리자만: 등록(`{id, role:'admin'|'user'}`, 디스코드에서 계정 확인) · 역할 변경 · 등록 해제 |
|
||||
| `GET /game-assets/<source>/<path>` | valorant-api.com · ddragon · cdragon 이미지 캐시 프록시 |
|
||||
|
||||
@@ -224,3 +224,50 @@ export type RelayFromDevice =
|
||||
| { t: 'res_head'; id: string; status: number; headers: Record<string, string> }
|
||||
| { t: 'res_end'; id: string }
|
||||
| { t: 'event'; event: LiveEvent };
|
||||
|
||||
// 앱(exe) 로그인 · 유저 등록 (사이트 서버 /auth/app/*, /app/*)
|
||||
/** superadmin = 최고 관리자(서버에 고정), admin = 관리자, user = 일반 유저 */
|
||||
export type AppRole = 'superadmin' | 'admin' | 'user';
|
||||
|
||||
export interface AppUserInfo {
|
||||
id: string;
|
||||
name: string;
|
||||
avatar: string | null;
|
||||
}
|
||||
|
||||
/** POST /auth/app/begin → 브라우저로 열 주소와 결과를 받아 갈 비밀값 */
|
||||
export interface AppLoginBegin {
|
||||
id: string;
|
||||
secret: string;
|
||||
url: string;
|
||||
expiresAt: number;
|
||||
}
|
||||
|
||||
/** POST /auth/app/poll 응답 */
|
||||
export type AppLoginPoll =
|
||||
| { state: 'pending' }
|
||||
| { state: 'ok'; token: string; user: AppUserInfo; role: AppRole }
|
||||
| { state: 'not_registered'; user: AppUserInfo }
|
||||
| { state: 'error'; error: string };
|
||||
|
||||
/** GET /app/me 응답 (등록된 유저만). botToken = 겜녹이 기본 봇 토큰 (서버에서만 내려준다) */
|
||||
export interface AppMe {
|
||||
user: AppUserInfo;
|
||||
role: AppRole;
|
||||
botToken: string | null;
|
||||
serverTime: number;
|
||||
}
|
||||
|
||||
/** 관리자 화면의 등록 유저 한 줄 */
|
||||
export interface AppUserRow {
|
||||
id: string;
|
||||
name: string;
|
||||
avatar: string | null;
|
||||
role: AppRole;
|
||||
/** 서버에 고정된 최고 관리자 (지우거나 역할을 바꿀 수 없음) */
|
||||
fixed: boolean;
|
||||
addedBy: string | null;
|
||||
addedAt: number | null;
|
||||
lastSeenAt: number | null;
|
||||
lastVersion: string | null;
|
||||
}
|
||||
|
||||
228
site/server/src/app-auth.ts
Normal file
228
site/server/src/app-auth.ts
Normal file
@@ -0,0 +1,228 @@
|
||||
// 앱(exe) 디스코드 로그인 · 유저 등록 · 관리자 API
|
||||
// 1) 앱: POST /auth/app/begin → {id, secret, url}. url 을 브라우저로 연다
|
||||
// 2) 브라우저: GET /auth/app/start/:id → 디스코드 OAuth → /auth/discord/callback (사이트 로그인과 같은 콜백, state 가 "app." 으로 시작)
|
||||
// 3) 콜백: 등록된 아이디면 앱 토큰 발급, 아니면 "등록되지 않은 아이디" 결과를 남긴다
|
||||
// 4) 앱: POST /auth/app/poll {id, secret} 로 결과를 받아 간다 (한 번만)
|
||||
// 5) 앱: GET /app/me (Bearer 토큰) 로 주기적으로 확인. 등록 해제되면 403 → 앱이 잠긴다. 겜녹이 봇 토큰은 여기서만 내려준다
|
||||
import crypto from 'node:crypto';
|
||||
import type { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify';
|
||||
import type { AppLoginPoll, AppMe, AppRole, AppUserInfo, AppUserRow } from '@gvr/shared';
|
||||
import type { Config } from './config.js';
|
||||
import { avatarUrl, fetchDiscordUser, type DiscordApi, type DiscordUser } from './discord.js';
|
||||
import type { ServerStore } from './store.js';
|
||||
|
||||
const LOGIN_TTL_MS = 10 * 60000;
|
||||
const MAX_PENDING = 200;
|
||||
const SNOWFLAKE = /^\d{17,20}$/;
|
||||
|
||||
interface Pending {
|
||||
secretHash: Buffer;
|
||||
nonce: string;
|
||||
expiresAt: number;
|
||||
result: AppLoginPoll | null;
|
||||
}
|
||||
|
||||
const sha = (s: string) => crypto.createHash('sha256').update(s).digest();
|
||||
|
||||
export function registerAppAuth(app: FastifyInstance, deps: { cfg: Config; store: ServerStore; discord: DiscordApi; secure: boolean }) {
|
||||
const { cfg, store, discord, secure } = deps;
|
||||
const pending = new Map<string, Pending>();
|
||||
|
||||
const roleOf = (id: string): AppRole | null => (cfg.superAdmins.includes(id) ? 'superadmin' : (store.appUser(id)?.role ?? null));
|
||||
const sweep = () => {
|
||||
const now = Date.now();
|
||||
for (const [k, p] of pending) if (p.expiresAt <= now) pending.delete(k);
|
||||
};
|
||||
const userInfo = (id: string): AppUserInfo => {
|
||||
const u = store.appUser(id);
|
||||
const seen = store.appSeen(id);
|
||||
return { id, name: u?.name || seen?.name || id, avatar: u?.avatar ?? seen?.avatar ?? null };
|
||||
};
|
||||
|
||||
// ------------------------------------------------------------------ 로그인 시작 · 결과 받기 (앱)
|
||||
app.post('/auth/app/begin', async (_req, reply) => {
|
||||
sweep();
|
||||
if (pending.size >= MAX_PENDING) return reply.code(429).send({ error: 'busy', message: '로그인 요청이 너무 많습니다. 잠시 뒤 다시 시도해 주세요' });
|
||||
const id = crypto.randomBytes(16).toString('base64url');
|
||||
const secret = crypto.randomBytes(32).toString('base64url');
|
||||
const expiresAt = Date.now() + LOGIN_TTL_MS;
|
||||
pending.set(id, { secretHash: sha(secret), nonce: crypto.randomBytes(16).toString('base64url'), expiresAt, result: null });
|
||||
return { id, secret, url: `${cfg.publicUrl}/auth/app/start/${id}`, expiresAt };
|
||||
});
|
||||
|
||||
app.post<{ Body: { id?: string; secret?: string } }>('/auth/app/poll', async (req, reply) => {
|
||||
const id = String(req.body?.id ?? '');
|
||||
const p = pending.get(id);
|
||||
const ok = p && p.expiresAt > Date.now() && crypto.timingSafeEqual(p.secretHash, sha(String(req.body?.secret ?? '')));
|
||||
if (!ok) return reply.code(410).send({ state: 'error', error: '로그인 요청이 만료되었습니다. 다시 로그인해 주세요' } satisfies AppLoginPoll);
|
||||
if (!p.result) return { state: 'pending' } satisfies AppLoginPoll;
|
||||
pending.delete(id); // 결과는 한 번만 내준다
|
||||
return p.result;
|
||||
});
|
||||
|
||||
// 브라우저: 로그인 요청 확인 → 디스코드 로그인으로
|
||||
app.get<{ Params: { id: string } }>('/auth/app/start/:id', async (req, reply) => {
|
||||
const p = pending.get(req.params.id);
|
||||
if (!p || p.expiresAt <= Date.now() || p.result) return page(reply, 410, '로그인 요청이 만료되었습니다', '겜녹이 앱에서 로그인 버튼을 다시 눌러 주세요.');
|
||||
const state = `app.${req.params.id}.${p.nonce}`;
|
||||
reply.setCookie('gvr_state', state, { path: '/auth', httpOnly: true, secure, sameSite: 'lax', maxAge: 600, signed: true });
|
||||
return reply.redirect(discord.authorizeUrl(state));
|
||||
});
|
||||
|
||||
/** /auth/discord/callback 에서 state 가 "app." 이면 여기로 온다 (state 쿠키 확인은 콜백에서 끝남) */
|
||||
async function completeLogin(state: string, code: string | undefined, error: string | undefined, reply: FastifyReply, log: FastifyRequest['log']) {
|
||||
const [, id = '', nonce = ''] = state.split('.');
|
||||
const p = pending.get(id);
|
||||
if (!p || p.nonce !== nonce || p.expiresAt <= Date.now() || p.result) return page(reply, 410, '로그인 요청이 만료되었습니다', '겜녹이 앱에서 로그인 버튼을 다시 눌러 주세요.');
|
||||
if (error || !code) {
|
||||
p.result = { state: 'error', error: '디스코드 로그인을 취소했습니다' };
|
||||
return page(reply, 200, '로그인을 취소했습니다', '겜녹이 앱에서 다시 시도할 수 있습니다.');
|
||||
}
|
||||
let u: DiscordUser;
|
||||
try {
|
||||
u = await discord.me((await discord.exchange(code)).access_token);
|
||||
} catch (e) {
|
||||
log.error(e, '앱 로그인 OAuth 실패');
|
||||
p.result = { state: 'error', error: '디스코드 로그인에 실패했습니다. 다시 시도해 주세요' };
|
||||
return page(reply, 502, '디스코드 로그인 실패', '잠시 뒤 겜녹이 앱에서 다시 시도해 주세요.');
|
||||
}
|
||||
const user: AppUserInfo = { id: u.id, name: u.global_name || u.username, avatar: avatarUrl(u) };
|
||||
const role = roleOf(u.id);
|
||||
if (!role) {
|
||||
log.info({ user: u.id }, '앱 로그인 거절: 등록되지 않은 아이디');
|
||||
p.result = { state: 'not_registered', user };
|
||||
return page(reply, 403, '등록되지 않은 아이디입니다', `${esc(user.name)} (${u.id}) 계정은 겜녹이 사용자로 등록되어 있지 않습니다. 관리자에게 이 아이디 등록을 요청해 주세요.`);
|
||||
}
|
||||
// 이름 · 사진은 로그인할 때마다 최신으로
|
||||
const row = store.appUser(u.id);
|
||||
if (row) store.upsertAppUser({ ...row, name: user.name, avatar: user.avatar });
|
||||
store.touchAppUser(u.id, { version: null, name: user.name, avatar: user.avatar });
|
||||
p.result = { state: 'ok', token: store.createAppSession(u.id), user, role };
|
||||
log.info({ user: u.id, role }, '앱 로그인');
|
||||
return page(reply, 200, '로그인 완료', `${esc(user.name)} 님, 겜녹이 앱으로 돌아가세요. 이 창은 닫아도 됩니다.`);
|
||||
}
|
||||
|
||||
// ------------------------------------------------------------------ 로그인 확인 (앱, Bearer 토큰)
|
||||
const bearer = (req: FastifyRequest) => /^Bearer\s+(\S+)$/i.exec(String(req.headers.authorization || ''))?.[1] ?? '';
|
||||
async function auth(req: FastifyRequest, reply: FastifyReply): Promise<{ id: string; role: AppRole } | null> {
|
||||
const token = bearer(req);
|
||||
const s = store.appSession(token);
|
||||
if (!s) {
|
||||
reply.code(401).send({ error: 'invalid_session', message: '다시 로그인해 주세요' });
|
||||
return null;
|
||||
}
|
||||
const role = roleOf(s.userId);
|
||||
if (!role) {
|
||||
store.deleteAppSession(token);
|
||||
reply.code(403).send({ error: 'not_registered', message: '등록되지 않은 아이디입니다', user: userInfo(s.userId) });
|
||||
return null;
|
||||
}
|
||||
return { id: s.userId, role };
|
||||
}
|
||||
|
||||
app.get('/app/me', async (req, reply) => {
|
||||
const a = await auth(req, reply);
|
||||
if (!a) return;
|
||||
const user = userInfo(a.id);
|
||||
const ver = String(req.headers['x-gvr-version'] || '').slice(0, 20) || null;
|
||||
store.touchAppUser(a.id, { version: ver, name: user.name, avatar: user.avatar });
|
||||
return { user, role: a.role, botToken: cfg.botToken || null, serverTime: Date.now() } satisfies AppMe;
|
||||
});
|
||||
|
||||
app.post('/auth/app/logout', async (req) => {
|
||||
const t = bearer(req);
|
||||
if (t) store.deleteAppSession(t);
|
||||
return { ok: true };
|
||||
});
|
||||
|
||||
// ------------------------------------------------------------------ 관리자: 유저 등록
|
||||
const rows = (): AppUserRow[] => {
|
||||
const fixed: AppUserRow[] = cfg.superAdmins.map((id) => {
|
||||
const seen = store.appSeen(id);
|
||||
return { id, name: seen?.name ?? id, avatar: seen?.avatar ?? null, role: 'superadmin', fixed: true, addedBy: null, addedAt: null, lastSeenAt: seen?.at ?? null, lastVersion: seen?.version ?? null };
|
||||
});
|
||||
const rest = store
|
||||
.appUsers()
|
||||
.filter((u) => !cfg.superAdmins.includes(u.id))
|
||||
.sort((a, b) => (a.role === b.role ? b.addedAt - a.addedAt : a.role === 'admin' ? -1 : 1))
|
||||
.map((u): AppUserRow => ({ id: u.id, name: u.name, avatar: u.avatar, role: u.role, fixed: false, addedBy: u.addedBy, addedAt: u.addedAt, lastSeenAt: u.lastSeenAt, lastVersion: u.lastVersion }));
|
||||
return [...fixed, ...rest];
|
||||
};
|
||||
const need = async (req: FastifyRequest, reply: FastifyReply, level: 'admin' | 'superadmin') => {
|
||||
const a = await auth(req, reply);
|
||||
if (!a) return null;
|
||||
const ok = level === 'superadmin' ? a.role === 'superadmin' : a.role !== 'user';
|
||||
if (!ok) {
|
||||
reply.code(403).send({ error: 'forbidden', message: level === 'superadmin' ? '유저 등록은 최고 관리자만 할 수 있습니다' : '관리자만 볼 수 있습니다' });
|
||||
return null;
|
||||
}
|
||||
return a;
|
||||
};
|
||||
const role = (v: unknown): 'admin' | 'user' | null => (v === 'admin' || v === 'user' ? v : null);
|
||||
|
||||
app.get('/app/admin/users', async (req, reply) => {
|
||||
if (!(await need(req, reply, 'admin'))) return;
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
app.post<{ Body: { id?: string; role?: string } }>('/app/admin/users', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const id = String(req.body?.id ?? '').trim();
|
||||
const r = role(req.body?.role ?? 'user');
|
||||
if (!SNOWFLAKE.test(id)) return reply.code(400).send({ error: 'bad_id', message: '디스코드 아이디는 17~20자리 숫자입니다' });
|
||||
if (!r) return reply.code(400).send({ error: 'bad_role', message: '역할은 관리자 또는 유저입니다' });
|
||||
if (cfg.superAdmins.includes(id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 이미 등록되어 있습니다' });
|
||||
let du: DiscordUser | null;
|
||||
try {
|
||||
du = await fetchDiscordUser(cfg, id);
|
||||
} catch (e) {
|
||||
req.log.warn(e, '디스코드 계정 조회 실패');
|
||||
return reply.code(502).send({ error: 'discord_error', message: '디스코드에서 계정을 확인하지 못했습니다. 잠시 뒤 다시 시도해 주세요' });
|
||||
}
|
||||
if (!du) return reply.code(404).send({ error: 'unknown_user', message: '디스코드에 없는 아이디입니다' });
|
||||
if ((du as any).bot) return reply.code(400).send({ error: 'bot', message: '봇 계정은 등록할 수 없습니다' });
|
||||
store.upsertAppUser({ id, name: du.global_name || du.username, avatar: avatarUrl(du), role: r, addedBy: a.id });
|
||||
req.log.info({ by: a.id, user: id, role: r }, '앱 유저 등록');
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
app.patch<{ Params: { id: string }; Body: { role?: string } }>('/app/admin/users/:id', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
const r = role(req.body?.role);
|
||||
if (!r) return reply.code(400).send({ error: 'bad_role', message: '역할은 관리자 또는 유저입니다' });
|
||||
if (cfg.superAdmins.includes(req.params.id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 바꿀 수 없습니다' });
|
||||
if (!store.setAppUserRole(req.params.id, r)) return reply.code(404).send({ error: 'not_found', message: '등록되지 않은 아이디입니다' });
|
||||
req.log.info({ by: a.id, user: req.params.id, role: r }, '앱 유저 역할 변경');
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
app.delete<{ Params: { id: string } }>('/app/admin/users/:id', async (req, reply) => {
|
||||
const a = await need(req, reply, 'superadmin');
|
||||
if (!a) return;
|
||||
if (cfg.superAdmins.includes(req.params.id)) return reply.code(400).send({ error: 'fixed', message: '최고 관리자는 지울 수 없습니다' });
|
||||
if (!store.removeAppUser(req.params.id)) return reply.code(404).send({ error: 'not_found', message: '등록되지 않은 아이디입니다' });
|
||||
req.log.info({ by: a.id, user: req.params.id }, '앱 유저 등록 해제');
|
||||
return { users: rows() };
|
||||
});
|
||||
|
||||
return { completeLogin };
|
||||
}
|
||||
|
||||
const esc = (s: string) => s.replace(/[&<>"']/g, (c) => `&#${c.charCodeAt(0)};`);
|
||||
|
||||
/** 브라우저에 보여 줄 짧은 안내 페이지 */
|
||||
function page(reply: FastifyReply, status: number, title: string, body: string) {
|
||||
const ok = status === 200;
|
||||
return reply
|
||||
.code(status)
|
||||
.type('text/html; charset=utf-8')
|
||||
.send(
|
||||
`<!doctype html><html lang="ko"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>겜녹이 · ${esc(title)}</title>` +
|
||||
`<style>body{margin:0;min-height:100vh;display:grid;place-items:center;background:#0b141c;color:#e6edf3;font-family:system-ui,'Malgun Gothic',sans-serif}` +
|
||||
`.c{max-width:420px;padding:32px;border-radius:14px;background:#121e29;border:1px solid #22313f;text-align:center}` +
|
||||
`h1{font-size:20px;margin:12px 0;color:${ok ? '#14c1b7' : '#ff4655'}}p{color:#9fb0c0;line-height:1.6;margin:0}.i{font-size:40px}</style></head>` +
|
||||
`<body><div class="c"><div class="i">${ok ? '✅' : '⛔'}</div><h1>${esc(title)}</h1><p>${body}</p></div></body></html>`,
|
||||
);
|
||||
}
|
||||
@@ -5,6 +5,7 @@ import crypto from 'node:crypto';
|
||||
import fs from 'node:fs';
|
||||
import path from 'node:path';
|
||||
import type { Config } from './config.js';
|
||||
import { registerAppAuth } from './app-auth.js';
|
||||
import { avatarUrl, DiscordApi } from './discord.js';
|
||||
import { RelayHub } from './relay.js';
|
||||
import { ServerStore, type Session } from './store.js';
|
||||
@@ -19,6 +20,7 @@ export async function buildServer(cfg: Config) {
|
||||
const discord = new DiscordApi(cfg);
|
||||
await app.register(cookie, { secret: cfg.sessionSecret });
|
||||
const secure = cfg.publicUrl.startsWith('https://');
|
||||
const appAuth = registerAppAuth(app, { cfg, store, discord, secure });
|
||||
|
||||
const allowedGuilds = (): string[] => {
|
||||
const g = new Set(cfg.allowedGuilds);
|
||||
@@ -70,6 +72,8 @@ export async function buildServer(cfg: Config) {
|
||||
app.get<{ Querystring: { code?: string; state?: string; error?: string } }>('/auth/discord/callback', async (req, reply) => {
|
||||
const st = req.cookies.gvr_state ? req.unsignCookie(req.cookies.gvr_state) : null;
|
||||
reply.clearCookie('gvr_state', { path: '/auth' });
|
||||
// 앱(exe) 로그인: 같은 콜백을 쓰고 state 가 "app." 으로 시작한다 (app-auth.ts)
|
||||
if (st?.valid && st.value && st.value === req.query.state && st.value.startsWith('app.')) return appAuth.completeLogin(st.value, req.query.code, req.query.error, reply, req.log);
|
||||
if (req.query.error) return reply.redirect('/?login=cancelled');
|
||||
if (!req.query.code || !st?.valid || st.value !== req.query.state) return reply.redirect('/?login=invalid');
|
||||
try {
|
||||
@@ -175,7 +179,7 @@ export async function buildServer(cfg: Config) {
|
||||
if (fs.existsSync(cfg.webDir)) {
|
||||
await app.register(fastifyStatic, { root: cfg.webDir, wildcard: false, index: ['index.html'] });
|
||||
app.setNotFoundHandler((req, reply) => {
|
||||
if (req.method === 'GET' && !req.url.startsWith('/api/') && !req.url.startsWith('/auth/') && !req.url.startsWith('/game-assets/'))
|
||||
if (req.method === 'GET' && !req.url.startsWith('/api/') && !req.url.startsWith('/auth/') && !req.url.startsWith('/app/') && !req.url.startsWith('/game-assets/'))
|
||||
return reply.type('text/html').send(fs.readFileSync(path.join(cfg.webDir, 'index.html')));
|
||||
return reply.code(404).send({ error: 'not_found' });
|
||||
});
|
||||
|
||||
@@ -9,7 +9,10 @@ export interface Config {
|
||||
botToken: string;
|
||||
/** 로그인 허용 디스코드 서버 (기본: M&L). 게임 PC 가 알려 준 서버도 함께 허용 */
|
||||
allowedGuilds: string[];
|
||||
/** 사이트 관리자 (게임 PC 등록 코드). 최고 관리자도 포함된다 */
|
||||
owners: string[];
|
||||
/** 앱 최고 관리자: 유저 등록·역할 변경. 지우거나 바꿀 수 없다 */
|
||||
superAdmins: string[];
|
||||
sessionSecret: string;
|
||||
dataDir: string;
|
||||
webDir: string;
|
||||
@@ -19,6 +22,11 @@ export interface Config {
|
||||
assetUpstream: Record<string, string>;
|
||||
}
|
||||
|
||||
/** 앱 최고 관리자 (사용자 지정, 고정). SUPER_ADMIN_IDS 환경변수로 더할 수 있다 */
|
||||
export const SUPER_ADMINS = ['293719842274541579', '1352267557213573160'];
|
||||
|
||||
const ids = (v: string | undefined) => (v || '').split(',').map((s) => s.trim()).filter(Boolean);
|
||||
|
||||
export function loadConfig(env = process.env): Config {
|
||||
const need = (k: string) => {
|
||||
const v = env[k];
|
||||
@@ -33,7 +41,8 @@ export function loadConfig(env = process.env): Config {
|
||||
clientSecret: need('DISCORD_CLIENT_SECRET'),
|
||||
botToken: need('DISCORD_BOT_TOKEN'),
|
||||
allowedGuilds: (env.ALLOWED_GUILD_IDS || '').split(',').map((s) => s.trim()).filter(Boolean),
|
||||
owners: (env.OWNER_DISCORD_IDS || '').split(',').map((s) => s.trim()).filter(Boolean),
|
||||
owners: [...new Set([...ids(env.OWNER_DISCORD_IDS), ...SUPER_ADMINS, ...ids(env.SUPER_ADMIN_IDS)])],
|
||||
superAdmins: [...new Set([...SUPER_ADMINS, ...ids(env.SUPER_ADMIN_IDS)])],
|
||||
sessionSecret: need('SESSION_SECRET'),
|
||||
dataDir: env.DATA_DIR || path.resolve('data'),
|
||||
webDir: env.WEB_DIR || path.resolve('../web/dist'),
|
||||
|
||||
@@ -54,6 +54,14 @@ export class DiscordApi {
|
||||
}
|
||||
}
|
||||
|
||||
/** 봇 토큰으로 디스코드 계정 조회 (유저 등록 때 이름 확인). 없는 아이디면 null */
|
||||
export async function fetchDiscordUser(cfg: Config, id: string): Promise<DiscordUser | null> {
|
||||
const r = await fetch(`${cfg.discordApi}/users/${id}`, { headers: { authorization: `Bot ${cfg.botToken}` } });
|
||||
if (r.status === 404 || r.status === 400) return null;
|
||||
if (!r.ok) throw new Error(`users/${id} ${r.status}`);
|
||||
return (await r.json()) as DiscordUser;
|
||||
}
|
||||
|
||||
export function avatarUrl(u: DiscordUser): string | null {
|
||||
return u.avatar ? `https://cdn.discordapp.com/avatars/${u.id}/${u.avatar}.png?size=128` : null;
|
||||
}
|
||||
|
||||
@@ -18,10 +18,32 @@ export interface Session {
|
||||
checkedAt: number;
|
||||
expiresAt: number;
|
||||
}
|
||||
/** 앱(exe)을 쓸 수 있게 등록된 디스코드 계정. 최고 관리자는 설정(config)에 고정이라 여기 없어도 된다 */
|
||||
export interface AppUser {
|
||||
id: string;
|
||||
name: string;
|
||||
avatar: string | null;
|
||||
role: 'admin' | 'user';
|
||||
addedBy: string;
|
||||
addedAt: number;
|
||||
lastSeenAt: number | null;
|
||||
lastVersion: string | null;
|
||||
}
|
||||
/** 앱 로그인 토큰 (서버는 해시만 저장) */
|
||||
export interface AppSession {
|
||||
tokenHash: string;
|
||||
userId: string;
|
||||
createdAt: number;
|
||||
expiresAt: number;
|
||||
}
|
||||
interface Data {
|
||||
devices: Device[];
|
||||
codes: { code: string; expiresAt: number; createdBy: string }[];
|
||||
sessions: Session[];
|
||||
appUsers: AppUser[];
|
||||
appSessions: AppSession[];
|
||||
/** 최고 관리자의 마지막 접속 (appUsers 에 없을 수 있어 따로 둔다) */
|
||||
appSeen: Record<string, { at: number; version: string | null; name: string; avatar: string | null }>;
|
||||
}
|
||||
// codes 는 server.json 에 두지 않는다 (codes.json)
|
||||
|
||||
@@ -44,10 +66,13 @@ export class ServerStore {
|
||||
try {
|
||||
this.d = JSON.parse(fs.readFileSync(this.file, 'utf8'));
|
||||
} catch {
|
||||
this.d = { devices: [], codes: [], sessions: [] };
|
||||
this.d = { devices: [], codes: [], sessions: [], appUsers: [], appSessions: [], appSeen: {} };
|
||||
}
|
||||
this.d.devices ||= [];
|
||||
this.d.sessions ||= [];
|
||||
this.d.appUsers ||= [];
|
||||
this.d.appSessions ||= [];
|
||||
this.d.appSeen ||= {};
|
||||
}
|
||||
|
||||
private save(now = false): void {
|
||||
@@ -149,4 +174,74 @@ export class ServerStore {
|
||||
this.d.sessions = this.d.sessions.filter((x) => x.id !== id);
|
||||
this.save();
|
||||
}
|
||||
|
||||
// ---- 앱 유저 등록 · 앱 로그인 토큰
|
||||
appUsers(): AppUser[] {
|
||||
return this.d.appUsers;
|
||||
}
|
||||
appUser(id: string): AppUser | null {
|
||||
return this.d.appUsers.find((u) => u.id === id) ?? null;
|
||||
}
|
||||
upsertAppUser(u: Pick<AppUser, 'id' | 'name' | 'avatar' | 'role' | 'addedBy'>): AppUser {
|
||||
const cur = this.appUser(u.id);
|
||||
if (cur) {
|
||||
Object.assign(cur, { name: u.name, avatar: u.avatar, role: u.role });
|
||||
this.save(true);
|
||||
return cur;
|
||||
}
|
||||
const row: AppUser = { ...u, addedAt: Date.now(), lastSeenAt: null, lastVersion: null };
|
||||
this.d.appUsers.push(row);
|
||||
this.save(true);
|
||||
return row;
|
||||
}
|
||||
setAppUserRole(id: string, role: AppUser['role']): AppUser | null {
|
||||
const u = this.appUser(id);
|
||||
if (!u) return null;
|
||||
u.role = role;
|
||||
this.save(true);
|
||||
return u;
|
||||
}
|
||||
/** 등록 해제. 그 유저의 앱 토큰은 다음 확인 때 403(등록되지 않은 아이디)을 받고 지워진다 */
|
||||
removeAppUser(id: string): boolean {
|
||||
const n = this.d.appUsers.length;
|
||||
this.d.appUsers = this.d.appUsers.filter((u) => u.id !== id);
|
||||
this.save(true);
|
||||
return this.d.appUsers.length !== n;
|
||||
}
|
||||
appSeen(id: string): Data['appSeen'][string] | null {
|
||||
return this.d.appSeen[id] ?? null;
|
||||
}
|
||||
touchAppUser(id: string, seen: { version: string | null; name: string; avatar: string | null }): void {
|
||||
const at = Date.now();
|
||||
this.d.appSeen[id] = { at, ...seen };
|
||||
const u = this.appUser(id);
|
||||
if (u) {
|
||||
u.lastSeenAt = at;
|
||||
u.lastVersion = seen.version;
|
||||
}
|
||||
this.save();
|
||||
}
|
||||
createAppSession(userId: string, ttlMs = 30 * 24 * 3600 * 1000): string {
|
||||
const token = crypto.randomBytes(32).toString('base64url');
|
||||
const now = Date.now();
|
||||
this.d.appSessions = this.d.appSessions.filter((x) => x.expiresAt > now);
|
||||
this.d.appSessions.push({ tokenHash: sha256(token), userId, createdAt: now, expiresAt: now + ttlMs });
|
||||
this.save(true);
|
||||
return token;
|
||||
}
|
||||
/** 토큰 확인. 쓸 때마다 만료를 30일 뒤로 민다 */
|
||||
appSession(token: string, ttlMs = 30 * 24 * 3600 * 1000): AppSession | null {
|
||||
if (!token) return null;
|
||||
const h = sha256(token);
|
||||
const s = this.d.appSessions.find((x) => x.tokenHash === h);
|
||||
if (!s || s.expiresAt <= Date.now()) return null;
|
||||
s.expiresAt = Date.now() + ttlMs;
|
||||
this.save();
|
||||
return s;
|
||||
}
|
||||
deleteAppSession(token: string): void {
|
||||
const h = sha256(token);
|
||||
this.d.appSessions = this.d.appSessions.filter((x) => x.tokenHash !== h);
|
||||
this.save(true);
|
||||
}
|
||||
}
|
||||
|
||||
169
site/server/test/app-auth.test.ts
Normal file
169
site/server/test/app-auth.test.ts
Normal file
@@ -0,0 +1,169 @@
|
||||
import { test } from 'node:test';
|
||||
import assert from 'node:assert/strict';
|
||||
import fs from 'node:fs';
|
||||
import http from 'node:http';
|
||||
import os from 'node:os';
|
||||
import path from 'node:path';
|
||||
import { buildServer } from '../src/app.ts';
|
||||
import type { Config } from '../src/config.ts';
|
||||
|
||||
const SUPER = '293719842274541579';
|
||||
const FRIEND = '111111111111111111';
|
||||
const STRANGER = '222222222222222222';
|
||||
const tmp = () => fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-appauth-'));
|
||||
|
||||
/** 가짜 디스코드: OAuth code 가 곧 로그인할 유저 아이디. 봇 토큰으로 /users/:id 조회 */
|
||||
async function fakeDiscord() {
|
||||
const known: Record<string, string> = { [SUPER]: '사금향', [FRIEND]: '친구', [STRANGER]: '모르는사람' };
|
||||
const srv = http.createServer((req, res) => {
|
||||
const u = new URL(req.url!, 'http://x');
|
||||
res.setHeader('content-type', 'application/json');
|
||||
if (u.pathname === '/oauth2/token') {
|
||||
let b = '';
|
||||
req.on('data', (c) => (b += c));
|
||||
req.on('end', () => res.end(JSON.stringify({ access_token: new URLSearchParams(b).get('code') })));
|
||||
return;
|
||||
}
|
||||
if (u.pathname === '/users/@me') {
|
||||
const id = String(req.headers.authorization).replace('Bearer ', '');
|
||||
return res.end(JSON.stringify({ id, username: known[id] ?? 'x', global_name: known[id] ?? null, avatar: null }));
|
||||
}
|
||||
const m = /^\/users\/(\d+)$/.exec(u.pathname);
|
||||
if (m && req.headers.authorization === 'Bot bot-token' && known[m[1]!]) return res.end(JSON.stringify({ id: m[1], username: known[m[1]!], global_name: known[m[1]!], avatar: null }));
|
||||
res.statusCode = 404;
|
||||
res.end('{}');
|
||||
});
|
||||
await new Promise<void>((r) => srv.listen(0, '127.0.0.1', () => r()));
|
||||
return { url: `http://127.0.0.1:${(srv.address() as any).port}`, close: () => srv.close() };
|
||||
}
|
||||
|
||||
async function setup() {
|
||||
const dc = await fakeDiscord();
|
||||
const cfg: Config = {
|
||||
port: 0, host: '127.0.0.1', publicUrl: 'http://127.0.0.1', clientId: 'cid', clientSecret: 's', botToken: 'bot-token',
|
||||
allowedGuilds: [], owners: [SUPER], superAdmins: [SUPER], sessionSecret: 'x'.repeat(32), dataDir: tmp(), webDir: '/nonexistent',
|
||||
version: 'test', discordApi: dc.url, assetUpstream: {},
|
||||
};
|
||||
const { app } = await buildServer(cfg);
|
||||
await app.listen({ host: '127.0.0.1', port: 0 });
|
||||
const base = `http://127.0.0.1:${(app.server.address() as any).port}`;
|
||||
const post = (p: string, body: unknown, token?: string) =>
|
||||
fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json', ...(token ? { authorization: `Bearer ${token}` } : {}) }, body: JSON.stringify(body) });
|
||||
/** 앱 로그인 한 번: begin → (브라우저) start → callback → poll */
|
||||
const login = async (userId: string) => {
|
||||
const b = (await (await post('/auth/app/begin', {})).json()) as any;
|
||||
assert.equal((await (await post('/auth/app/poll', { id: b.id, secret: b.secret })).json() as any).state, 'pending');
|
||||
const start = await fetch(b.url.replace('http://127.0.0.1', base), { redirect: 'manual' });
|
||||
assert.equal(start.status, 302);
|
||||
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
|
||||
assert.ok(state.startsWith('app.'));
|
||||
const cookie = start.headers.getSetCookie()[0]!.split(';')[0]!;
|
||||
const cb = await fetch(`${base}/auth/discord/callback?code=${userId}&state=${encodeURIComponent(state)}`, { headers: { cookie }, redirect: 'manual' });
|
||||
const html = await cb.text();
|
||||
const r = (await (await post('/auth/app/poll', { id: b.id, secret: b.secret })).json()) as any;
|
||||
// 결과는 한 번만 받는다
|
||||
assert.equal((await post('/auth/app/poll', { id: b.id, secret: b.secret })).status, 410);
|
||||
return { r, status: cb.status, html };
|
||||
};
|
||||
const me = (t: string) => fetch(base + '/app/me', { headers: { authorization: `Bearer ${t}`, 'x-gvr-version': '1.2.0' } });
|
||||
const close = async () => {
|
||||
await app.close();
|
||||
dc.close();
|
||||
};
|
||||
return { base, post, login, me, close };
|
||||
}
|
||||
|
||||
test('앱 로그인: 최고 관리자는 바로 로그인, 미등록 아이디는 거절, 등록하면 로그인 · 해제하면 바로 잠김', async () => {
|
||||
const s = await setup();
|
||||
try {
|
||||
// 비밀값이 틀리면 결과를 못 받는다
|
||||
const b = (await (await s.post('/auth/app/begin', {})).json()) as any;
|
||||
assert.equal((await s.post('/auth/app/poll', { id: b.id, secret: 'wrong' })).status, 410);
|
||||
|
||||
// 최고 관리자 (서버에 고정)
|
||||
const sup = await s.login(SUPER);
|
||||
assert.equal(sup.status, 200);
|
||||
assert.equal(sup.r.state, 'ok');
|
||||
assert.equal(sup.r.role, 'superadmin');
|
||||
const meSup = (await (await s.me(sup.r.token)).json()) as any;
|
||||
assert.equal(meSup.role, 'superadmin');
|
||||
assert.equal(meSup.botToken, 'bot-token', '등록된 유저에게만 겜녹이 봇 토큰을 내려준다');
|
||||
|
||||
// 미등록 아이디
|
||||
const no = await s.login(STRANGER);
|
||||
assert.equal(no.status, 403);
|
||||
assert.match(no.html, /등록되지 않은 아이디/);
|
||||
assert.equal(no.r.state, 'not_registered');
|
||||
assert.equal(no.r.user.id, STRANGER);
|
||||
assert.equal(no.r.token, undefined);
|
||||
|
||||
// 토큰 없이 · 틀린 토큰으로는 아무것도 못 받는다
|
||||
assert.equal((await fetch(s.base + '/app/me')).status, 401);
|
||||
assert.equal((await s.me('nope')).status, 401);
|
||||
|
||||
// 최고 관리자가 친구를 유저로 등록
|
||||
const add = await s.post('/app/admin/users', { id: FRIEND, role: 'user' }, sup.r.token);
|
||||
assert.equal(add.status, 200);
|
||||
const list = ((await add.json()) as any).users;
|
||||
assert.deepEqual(list.map((u: any) => [u.id, u.role, u.fixed]), [[SUPER, 'superadmin', true], [FRIEND, 'user', false]]);
|
||||
assert.equal(list[1].name, '친구');
|
||||
assert.equal(list[1].addedBy, SUPER);
|
||||
// 잘못된 아이디 · 없는 계정 · 최고 관리자 재등록
|
||||
assert.equal((await s.post('/app/admin/users', { id: '123' }, sup.r.token)).status, 400);
|
||||
assert.equal((await s.post('/app/admin/users', { id: '333333333333333333' }, sup.r.token)).status, 404);
|
||||
assert.equal((await s.post('/app/admin/users', { id: SUPER }, sup.r.token)).status, 400);
|
||||
|
||||
const fr = await s.login(FRIEND);
|
||||
assert.equal(fr.r.state, 'ok');
|
||||
assert.equal(fr.r.role, 'user');
|
||||
const meFr = (await (await s.me(fr.r.token)).json()) as any;
|
||||
assert.equal(meFr.user.name, '친구');
|
||||
// 일반 유저는 관리자 API 를 못 쓴다
|
||||
assert.equal((await fetch(s.base + '/app/admin/users', { headers: { authorization: `Bearer ${fr.r.token}` } })).status, 403);
|
||||
assert.equal((await s.post('/app/admin/users', { id: STRANGER }, fr.r.token)).status, 403);
|
||||
|
||||
// 관리자로 올리면 목록은 볼 수 있지만 등록은 못 한다 (등록은 최고 관리자만)
|
||||
assert.equal((await fetch(`${s.base}/app/admin/users/${FRIEND}`, { method: 'PATCH', headers: { 'content-type': 'application/json', authorization: `Bearer ${sup.r.token}` }, body: JSON.stringify({ role: 'admin' }) })).status, 200);
|
||||
const asAdmin = (await (await fetch(s.base + '/app/admin/users', { headers: { authorization: `Bearer ${fr.r.token}` } })).json()) as any;
|
||||
assert.equal(asAdmin.users.find((u: any) => u.id === FRIEND).role, 'admin');
|
||||
assert.equal(asAdmin.users.find((u: any) => u.id === FRIEND).lastVersion, '1.2.0', '마지막 접속 버전 기록');
|
||||
assert.equal((await s.post('/app/admin/users', { id: STRANGER }, fr.r.token)).status, 403);
|
||||
assert.equal((await fetch(`${s.base}/app/admin/users/${SUPER}`, { method: 'DELETE', headers: { authorization: `Bearer ${sup.r.token}` } })).status, 400, '최고 관리자는 못 지운다');
|
||||
|
||||
// 등록 해제 → 그 유저 토큰은 바로 무효
|
||||
assert.equal((await fetch(`${s.base}/app/admin/users/${FRIEND}`, { method: 'DELETE', headers: { authorization: `Bearer ${sup.r.token}` } })).status, 200);
|
||||
const revoked = await s.me(fr.r.token);
|
||||
assert.equal(revoked.status, 403);
|
||||
assert.equal(((await revoked.json()) as any).error, 'not_registered');
|
||||
assert.equal((await s.me(fr.r.token)).status, 401, '한 번 거절한 토큰은 지운다');
|
||||
const again = await s.login(FRIEND);
|
||||
assert.equal(again.r.state, 'not_registered');
|
||||
|
||||
// 로그아웃하면 토큰 무효
|
||||
await s.post('/auth/app/logout', {}, sup.r.token);
|
||||
assert.equal((await s.me(sup.r.token)).status, 401);
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
|
||||
test('앱 로그인: 만료되거나 이미 쓴 요청 · 위조한 state 는 거절', async () => {
|
||||
const s = await setup();
|
||||
try {
|
||||
assert.equal((await fetch(s.base + '/auth/app/start/nope', { redirect: 'manual' })).status, 410);
|
||||
const b = (await (await s.post('/auth/app/begin', {})).json()) as any;
|
||||
const start = await fetch(b.url.replace('http://127.0.0.1', s.base), { redirect: 'manual' });
|
||||
const state = new URL(start.headers.get('location')!).searchParams.get('state')!;
|
||||
// state 쿠키 없이 콜백 → 앱 로그인으로 처리하지 않는다
|
||||
const cb = await fetch(`${s.base}/auth/discord/callback?code=${SUPER}&state=${encodeURIComponent(state)}`, { redirect: 'manual' });
|
||||
assert.equal(cb.headers.get('location'), '/?login=invalid');
|
||||
assert.equal(((await (await s.post('/auth/app/poll', { id: b.id, secret: b.secret })).json()) as any).state, 'pending');
|
||||
// 디스코드에서 취소
|
||||
const cookie = start.headers.getSetCookie()[0]!.split(';')[0]!;
|
||||
await fetch(`${s.base}/auth/discord/callback?error=access_denied&state=${encodeURIComponent(state)}`, { headers: { cookie }, redirect: 'manual' });
|
||||
const r = (await (await s.post('/auth/app/poll', { id: b.id, secret: b.secret })).json()) as any;
|
||||
assert.equal(r.state, 'error');
|
||||
} finally {
|
||||
await s.close();
|
||||
}
|
||||
});
|
||||
@@ -10,7 +10,7 @@ import type { Config } from '../src/config.ts';
|
||||
test('사이트 서버 재시작 → 게임 PC 자동 재연결', async () => {
|
||||
const dataDir = fs.mkdtempSync(path.join(process.env.TMPDIR || os.tmpdir(), 'gvr-rc-'));
|
||||
const cfg = (port: number): Config => ({
|
||||
port, host: '127.0.0.1', publicUrl: 'http://127.0.0.1', clientId: 'x', clientSecret: 'x', botToken: 'x', allowedGuilds: [], owners: [],
|
||||
port, host: '127.0.0.1', publicUrl: 'http://127.0.0.1', clientId: 'x', clientSecret: 'x', botToken: 'x', allowedGuilds: [], owners: [], superAdmins: [],
|
||||
sessionSecret: 'y'.repeat(32), dataDir, webDir: '/nonexistent', version: 't', discordApi: 'http://127.0.0.1:1', assetUpstream: {},
|
||||
});
|
||||
let s = await buildServer(cfg(0));
|
||||
|
||||
@@ -42,6 +42,7 @@ test('사이트 서버: 로그인 → 기기 등록·연결 → 중계(JSON·음
|
||||
botToken: 'bot',
|
||||
allowedGuilds: ['111'],
|
||||
owners: ['owner1'],
|
||||
superAdmins: [],
|
||||
sessionSecret: 'x'.repeat(32),
|
||||
dataDir: tmp(),
|
||||
webDir: '/nonexistent',
|
||||
|
||||
@@ -8,8 +8,6 @@
|
||||
# ==================================================================
|
||||
$TargetRev = '__REV__'
|
||||
$Phase = '__PHASE__'
|
||||
# 겜녹이 기본 봇 토큰 (run.sh 가 full 빌드에만 박는다. 빈 값이면 기본 봇 없는 빌드). 끝나면 finally 에서 이 스크립트 사본째 지운다
|
||||
$BuiltinBot = '__BUILTIN_BOT__'
|
||||
$Repo = 'C:\win-ci\gvr'
|
||||
$OutDir = 'C:\win-ci\gvr-out'
|
||||
New-Item -ItemType Directory -Force -Path $OutDir | Out-Null
|
||||
@@ -133,13 +131,8 @@ try {
|
||||
Push-Location (Join-Path $Repo 'app')
|
||||
& npm.cmd ci --no-audit --no-fund
|
||||
if ($LASTEXITCODE -ne 0) { Pop-Location; throw "npm ci exit $LASTEXITCODE" }
|
||||
try {
|
||||
$env:GVR_BUILTIN_BOT_TOKEN = $BuiltinBot
|
||||
& npm.cmd run dist:win
|
||||
$c = $LASTEXITCODE
|
||||
} finally {
|
||||
Remove-Item Env:GVR_BUILTIN_BOT_TOKEN -ErrorAction SilentlyContinue
|
||||
}
|
||||
& npm.cmd run dist:win
|
||||
$c = $LASTEXITCODE
|
||||
Pop-Location
|
||||
if ($c -ne 0) { throw "electron-builder exit $c" }
|
||||
Get-ChildItem app\release -File | ForEach-Object { "$($_.Name) $([math]::Round($_.Length / 1MB, 1)) MB" }
|
||||
@@ -168,14 +161,6 @@ try {
|
||||
} catch {
|
||||
Log "gvr 검증 준비 실패: $($_.Exception.Message)"
|
||||
try { Pop-Location } catch {}
|
||||
} finally {
|
||||
if ($BuiltinBot) {
|
||||
# 성공·실패와 상관없이 게스트에 토큰을 남기지 않는다: 이 스크립트 사본(평문), 빌드 산출물(감춘 값. exe 는 이미 호스트로 보냄)
|
||||
Remove-Item Env:GVR_BUILTIN_BOT_TOKEN -ErrorAction SilentlyContinue
|
||||
Remove-Item (Join-Path $Repo 'app\dist'), (Join-Path $Repo 'app\release') -Recurse -Force -ErrorAction SilentlyContinue
|
||||
Remove-Item $PSCommandPath -Force -ErrorAction SilentlyContinue
|
||||
Log "기본 봇 토큰 정리: stage2 사본 삭제=$(-not (Test-Path $PSCommandPath)), 빌드 산출물 삭제=$(-not (Test-Path (Join-Path $Repo 'app\release')))"
|
||||
}
|
||||
}
|
||||
Log "=== gvr 끝 ==="
|
||||
exit 0
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
# 공용 win-ci VM 의 stage2.ps1 을 겜녹이 작업 전 상태로 되돌린다.
|
||||
# restore.sh 지금 바로 되돌린다
|
||||
# restore.sh --wait gvr-summary.log 가 생길 때까지(최대 3시간) 기다렸다가 되돌린다 (run.sh 가 자동으로 띄운다)
|
||||
# full 빌드의 stage2 에는 겜녹이 기본 봇 토큰이 평문으로 들어 있으므로, 성공·실패와 상관없이 반드시 지워야 한다.
|
||||
# 공용 VM 이라 성공·실패와 상관없이 다른 작업의 stage2 로 되돌려 둔다.
|
||||
D=/home/claude/win-ci
|
||||
if [ "${1:-}" = --wait ]; then
|
||||
for _ in $(seq 1 1080); do
|
||||
@@ -15,6 +15,6 @@ if [ ! -f $D/serve/stage2.ps1.bak-gvr ]; then
|
||||
elif grep -q 'game_voice_recorder' $D/serve/stage2.ps1 2>/dev/null; then
|
||||
mv $D/serve/stage2.ps1.bak-gvr $D/serve/stage2.ps1 && echo "복원 완료"
|
||||
else
|
||||
# 그 사이 다른 작업이 stage2 를 바꿨다 - 그것은 건드리지 않고 보관본만 지운다 (겜녹이 토큰은 이미 없다)
|
||||
# 그 사이 다른 작업이 stage2 를 바꿨다 - 그것은 건드리지 않고 보관본만 지운다
|
||||
rm -f $D/serve/stage2.ps1.bak-gvr && echo "stage2 는 다른 작업 것이라 그대로 두고 보관본만 삭제"
|
||||
fi
|
||||
|
||||
@@ -9,18 +9,11 @@ D=/home/claude/win-ci
|
||||
HERE="$(cd "$(dirname "$0")" && pwd)"
|
||||
[ -f $D/serve/stage2.ps1.bak-gvr ] || cp $D/serve/stage2.ps1 $D/serve/stage2.ps1.bak-gvr
|
||||
rm -f $D/results/gvr-summary.log
|
||||
# full 빌드: 겜녹이 기본 봇 토큰을 secrets.json 에서 읽어 이번 stage2 에만 넣는다 (저장소·로그에는 남기지 않는다.
|
||||
# stage2 는 127.0.0.1 로만 내려주고, 끝나면 아래 자동 복원이 지운다. 게스트 쪽 사본은 gvr.ps1 이 스스로 지운다)
|
||||
BOT=''
|
||||
if [ "$PHASE" = full ]; then
|
||||
BOT=$(python3 -c "import json;print(json.load(open('/home/claude/.config/ejclaw/secrets.json'))['credentials']['discord.com/bot/game-voice-recorder']['token'])")
|
||||
# sed 치환과 PowerShell '...' 문자열에 그대로 넣으므로 디스코드 토큰 글자(영숫자 . _ -)만 허용한다
|
||||
[[ "$BOT" =~ ^[A-Za-z0-9._-]+$ ]] || { echo "기본 봇 토큰 형식이 이상하다 (secrets.json 확인)" >&2; exit 1; }
|
||||
fi
|
||||
# 겜녹이 봇 토큰은 exe 에 넣지 않는다 (v1.2.0~ 로그인한 등록 유저에게 사이트 서버가 내려준다). 빌드에 비밀값이 필요 없다
|
||||
umask 077
|
||||
{ cat "$HERE/preamble.ps1"; sed "s/__REV__/$REV/; s/__PHASE__/$PHASE/; s|__BUILTIN_BOT__|$BOT|" "$HERE/gvr.ps1"; } > $D/serve/stage2.ps1.new
|
||||
{ cat "$HERE/preamble.ps1"; sed "s/__REV__/$REV/; s/__PHASE__/$PHASE/" "$HERE/gvr.ps1"; } > $D/serve/stage2.ps1.new
|
||||
mv $D/serve/stage2.ps1.new $D/serve/stage2.ps1
|
||||
echo "stage2 배포: phase=$PHASE rev=$REV 기본 봇=$([ -n "$BOT" ] && echo 포함 || echo 없음) (게스트가 20초 안에 받아간다)"
|
||||
echo "stage2 배포: phase=$PHASE rev=$REV (게스트가 20초 안에 받아간다)"
|
||||
# 자동 복원: gvr-summary.log 가 오면(성공·실패 모두 마지막에 보낸다) 또는 3시간이 지나면 stage2 를 되돌린다.
|
||||
# 이 셸이 끝나도 살아 있게 systemd 사용자 유닛으로 띄운다
|
||||
systemctl --user stop gvr-ci-restore.service 2>/dev/null || true
|
||||
|
||||
Reference in New Issue
Block a user