purewhiter--mobilegym
wehub-resource-sync
1470 行
51 KiB
TypeScript
可执行文件
1470 行
51 KiB
TypeScript
可执行文件
|
||
import path from 'path';
|
||
import fs from 'fs';
|
||
import { Readable } from 'stream';
|
||
import { execFileSync, spawn, type ChildProcess } from 'child_process';
|
||
import { fileURLToPath } from 'url';
|
||
import { defineConfig, loadEnv } from 'vite';
|
||
import react from '@vitejs/plugin-react';
|
||
|
||
// Fix for __dirname in ESM
|
||
const __filename = fileURLToPath(import.meta.url);
|
||
const __dirname = path.dirname(__filename);
|
||
|
||
/**
|
||
* Vite plugin to log HTTP access requests
|
||
* Works for both dev server (npm run dev) and preview server (npm run preview)
|
||
*/
|
||
function accessLogPlugin() {
|
||
const logMiddleware = (req, res, next) => {
|
||
const start = Date.now();
|
||
const originalEnd = res.end;
|
||
|
||
res.end = function(...args) {
|
||
const duration = Date.now() - start;
|
||
const time = new Date().toLocaleTimeString('zh-CN', { hour12: false });
|
||
const status = res.statusCode;
|
||
const method = req.method || 'GET';
|
||
const url = req.url || '/';
|
||
|
||
const statusColor = status >= 400 ? '\x1b[31m' : status >= 300 ? '\x1b[33m' : '\x1b[32m';
|
||
console.log(`${time} \x1b[36m${method}\x1b[0m ${url} ${statusColor}${status}\x1b[0m ${duration}ms`);
|
||
|
||
return originalEnd.apply(this, args);
|
||
};
|
||
|
||
next();
|
||
};
|
||
|
||
return {
|
||
name: 'access-log',
|
||
configureServer(server) {
|
||
server.middlewares.use(logMiddleware);
|
||
},
|
||
configurePreviewServer(server) {
|
||
server.middlewares.use(logMiddleware);
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Vite plugin to provide /api/list-public-files endpoint
|
||
* This allows HTML viewers to auto-discover data files in the public directory
|
||
*/
|
||
function listPublicFilesPlugin() {
|
||
return {
|
||
name: 'list-public-files',
|
||
configureServer(server) {
|
||
server.middlewares.use('/api/list-public-files', (req, res) => {
|
||
const publicDir = path.resolve(__dirname, 'public');
|
||
|
||
try {
|
||
const files = fs.readdirSync(publicDir);
|
||
|
||
// Categorize files based on naming patterns
|
||
const actionTasks: { id: string; label: string; file: string }[] = [];
|
||
const navGraphs: { id: string; label: string; file: string }[] = [];
|
||
|
||
for (const file of files) {
|
||
const filePath = path.join(publicDir, file);
|
||
const stat = fs.statSync(filePath);
|
||
if (!stat.isFile()) continue;
|
||
|
||
const lowerFile = file.toLowerCase();
|
||
|
||
// Action tasks: *_action_tasks*.json or *_action_tasks*.jsonl
|
||
if (lowerFile.includes('action_tasks') && (file.endsWith('.json') || file.endsWith('.jsonl'))) {
|
||
actionTasks.push({
|
||
id: file.replace(/\.[^.]+$/, ''),
|
||
label: generateLabel(file, 'action_tasks'),
|
||
file: `/${file}`,
|
||
});
|
||
}
|
||
// Nav graphs: *_nav_graph*.json OR *_data_graph*.json (both use same format)
|
||
else if ((lowerFile.includes('nav_graph') || lowerFile.includes('data_graph')) && file.endsWith('.json')) {
|
||
navGraphs.push({
|
||
id: file.replace(/\.[^.]+$/, ''),
|
||
label: generateLabel(file, lowerFile.includes('data_graph') ? 'data_graph' : 'nav_graph'),
|
||
file: `/${file}`,
|
||
});
|
||
}
|
||
}
|
||
|
||
// Sort by filename
|
||
const sortByFile = (a, b) => a.file.localeCompare(b.file);
|
||
actionTasks.sort(sortByFile);
|
||
navGraphs.sort(sortByFile);
|
||
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({
|
||
action_tasks: actionTasks,
|
||
nav_graphs: navGraphs,
|
||
}));
|
||
} catch (err) {
|
||
res.statusCode = 500;
|
||
res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
|
||
}
|
||
});
|
||
}
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Vite plugin for file system scanning with caching
|
||
* Provides /api/sdcard endpoint - scans only when files change
|
||
*/
|
||
function fileSystemPlugin() {
|
||
const SDCARD_DIR = path.resolve(__dirname, 'public/sdcard');
|
||
|
||
// 缓存扫描结果
|
||
let cachedResult: {
|
||
totalFiles: number;
|
||
totalDirectories: number;
|
||
files: any[];
|
||
directories: any[];
|
||
} | null = null;
|
||
let cacheValid = false;
|
||
|
||
const MIME_TYPES: Record<string, string> = {
|
||
'.jpg': 'image/jpeg',
|
||
'.jpeg': 'image/jpeg',
|
||
'.png': 'image/png',
|
||
'.gif': 'image/gif',
|
||
'.webp': 'image/webp',
|
||
'.svg': 'image/svg+xml',
|
||
'.mp4': 'video/mp4',
|
||
'.webm': 'video/webm',
|
||
'.mov': 'video/quicktime',
|
||
'.avi': 'video/x-msvideo',
|
||
'.mp3': 'audio/mpeg',
|
||
'.wav': 'audio/wav',
|
||
'.ogg': 'audio/ogg',
|
||
'.flac': 'audio/flac',
|
||
'.pdf': 'application/pdf',
|
||
'.doc': 'application/msword',
|
||
'.docx': 'application/vnd.openxmlformats-officedocument.wordprocessingml.document',
|
||
'.xls': 'application/vnd.ms-excel',
|
||
'.xlsx': 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet',
|
||
'.ppt': 'application/vnd.ms-powerpoint',
|
||
'.pptx': 'application/vnd.openxmlformats-officedocument.presentationml.presentation',
|
||
'.txt': 'text/plain',
|
||
'.json': 'application/json',
|
||
'.zip': 'application/zip',
|
||
'.apk': 'application/vnd.android.package-archive',
|
||
};
|
||
|
||
function getMimeType(fileName: string) {
|
||
const ext = path.extname(fileName).toLowerCase();
|
||
return MIME_TYPES[ext] || 'application/octet-stream';
|
||
}
|
||
|
||
function scanDirectory(dir: string, basePath = ''): { files: any[]; directories: any[] } {
|
||
const result = { files: [] as any[], directories: [] as any[] };
|
||
if (!fs.existsSync(dir)) return result;
|
||
|
||
const entries = fs.readdirSync(dir, { withFileTypes: true });
|
||
|
||
for (const entry of entries) {
|
||
const fullPath = path.join(dir, entry.name);
|
||
const relativePath = basePath ? `${basePath}/${entry.name}` : entry.name;
|
||
|
||
// Do not skip system dot directories (e.g. `.data`, `.cache`).
|
||
// Only skip known noisy OS/generated files.
|
||
if (entry.name === '.DS_Store' || entry.name === 'manifest.json') continue;
|
||
|
||
if (entry.isDirectory()) {
|
||
const stats = fs.statSync(fullPath);
|
||
// 添加目录本身
|
||
result.directories.push({
|
||
path: '/sdcard/' + relativePath,
|
||
name: entry.name,
|
||
modifiedAt: stats.mtimeMs,
|
||
});
|
||
// 递归扫描子目录
|
||
const sub = scanDirectory(fullPath, relativePath);
|
||
result.files.push(...sub.files);
|
||
result.directories.push(...sub.directories);
|
||
} else if (entry.isFile()) {
|
||
const stats = fs.statSync(fullPath);
|
||
result.files.push({
|
||
path: '/sdcard/' + relativePath,
|
||
uri: '/sdcard/' + relativePath,
|
||
name: entry.name,
|
||
mimeType: getMimeType(entry.name),
|
||
size: stats.size,
|
||
modifiedAt: stats.mtimeMs,
|
||
});
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
|
||
function refreshCache() {
|
||
if (!fs.existsSync(SDCARD_DIR)) {
|
||
fs.mkdirSync(SDCARD_DIR, { recursive: true });
|
||
}
|
||
const { files, directories } = scanDirectory(SDCARD_DIR);
|
||
cachedResult = {
|
||
totalFiles: files.length,
|
||
totalDirectories: directories.length,
|
||
files,
|
||
directories
|
||
};
|
||
cacheValid = true;
|
||
console.log(`[sdcard] Scanned ${files.length} files, ${directories.length} directories`);
|
||
}
|
||
|
||
return {
|
||
name: 'filesystem-api',
|
||
|
||
// Build: emit static manifest so FileSystemService can discover files without /api/sdcard
|
||
generateBundle() {
|
||
const { files, directories } = scanDirectory(SDCARD_DIR);
|
||
const manifest = {
|
||
totalFiles: files.length,
|
||
totalDirectories: directories.length,
|
||
files,
|
||
directories,
|
||
};
|
||
(this as any).emitFile({
|
||
type: 'asset',
|
||
fileName: 'sdcard/manifest.json',
|
||
source: JSON.stringify(manifest),
|
||
});
|
||
console.log(`[sdcard] Emitted manifest.json (${files.length} files, ${directories.length} dirs)`);
|
||
},
|
||
|
||
configureServer(server) {
|
||
// 初始扫描
|
||
refreshCache();
|
||
|
||
// 监视文件变化，使缓存失效
|
||
server.watcher.add(SDCARD_DIR);
|
||
server.watcher.on('all', (event, filePath) => {
|
||
if (filePath.startsWith(SDCARD_DIR)) {
|
||
const basename = path.basename(filePath);
|
||
// Only skip known OS-generated noise files, not system dot-directories like .data
|
||
if (basename === '.DS_Store' || basename === 'manifest.json') return;
|
||
cacheValid = false;
|
||
console.log(`[sdcard] ${event}: ${path.relative(SDCARD_DIR, filePath)}`);
|
||
}
|
||
});
|
||
|
||
// API 端点 - 使用缓存
|
||
server.middlewares.use('/api/sdcard', (_req, res) => {
|
||
try {
|
||
// 只在缓存失效时重新扫描
|
||
if (!cacheValid) {
|
||
refreshCache();
|
||
}
|
||
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify(cachedResult));
|
||
} catch (err: any) {
|
||
res.statusCode = 500;
|
||
res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
|
||
}
|
||
});
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Vite plugin to serve runs directory for run_explorer.html
|
||
* Provides /api/runs endpoints to list and read run data
|
||
*/
|
||
function runsExplorerPlugin() {
|
||
const RUNS_DIR = path.resolve(__dirname, 'runs');
|
||
|
||
return {
|
||
name: 'runs-explorer-api',
|
||
|
||
configureServer(server) {
|
||
// GET /api/runs - List all run directories
|
||
server.middlewares.use('/api/runs', (req, res, next) => {
|
||
const url = new URL(req.url || '/', `http://${req.headers.host}`);
|
||
const pathParts = url.pathname.split('/').filter(Boolean);
|
||
|
||
const isRunDir = (dir: string) => {
|
||
return fs.existsSync(path.join(dir, 'meta.json'))
|
||
|| fs.existsSync(path.join(dir, 'results.jsonl'))
|
||
|| fs.existsSync(path.join(dir, 'trajectory'));
|
||
};
|
||
const isDirEntry = (e: fs.Dirent) => e.isDirectory() || e.isSymbolicLink();
|
||
|
||
// /api/runs - list runs (supports nested dirs like agent/timestamp)
|
||
if (pathParts.length === 0) {
|
||
try {
|
||
if (!fs.existsSync(RUNS_DIR)) {
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ runs: [] }));
|
||
return;
|
||
}
|
||
|
||
|
||
|
||
const runs: string[] = [];
|
||
const topEntries = fs.readdirSync(RUNS_DIR, { withFileTypes: true });
|
||
for (const e of topEntries) {
|
||
if (!isDirEntry(e)) continue;
|
||
const topDir = path.join(RUNS_DIR, e.name);
|
||
if (isRunDir(topDir)) {
|
||
// Flat: runs/<run_name>/meta.json
|
||
runs.push(e.name);
|
||
} else {
|
||
// Nested: runs/<agent>/<timestamp>/meta.json
|
||
const subEntries = fs.readdirSync(topDir, { withFileTypes: true });
|
||
for (const sub of subEntries) {
|
||
if (!isDirEntry(sub)) continue;
|
||
if (isRunDir(path.join(topDir, sub.name))) {
|
||
runs.push(`${e.name}/${sub.name}`);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
runs.sort((a, b) => b.localeCompare(a));
|
||
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ runs }));
|
||
} catch (err: any) {
|
||
res.statusCode = 500;
|
||
res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
|
||
}
|
||
return;
|
||
}
|
||
|
||
// /api/runs/:runName/... - access run files
|
||
// runName can be 1-part (flat) or 2-part (nested: agent/timestamp)
|
||
|
||
|
||
let runDepth = 1; // how many pathParts make up the runName
|
||
let runDir = path.join(RUNS_DIR, pathParts[0]);
|
||
|
||
// Try nested: pathParts[0]/pathParts[1]
|
||
if (pathParts.length >= 2 && !isRunDir(runDir)) {
|
||
const nested = path.join(RUNS_DIR, pathParts[0], pathParts[1]);
|
||
if (fs.existsSync(nested) && fs.statSync(nested).isDirectory()) {
|
||
runDir = nested;
|
||
runDepth = 2;
|
||
}
|
||
}
|
||
|
||
const runName = pathParts.slice(0, runDepth).join('/');
|
||
|
||
// Security: prevent path traversal
|
||
if (!runDir.startsWith(RUNS_DIR) || runName.includes('..')) {
|
||
res.statusCode = 403;
|
||
res.end(JSON.stringify({ error: 'Forbidden' }));
|
||
return;
|
||
}
|
||
|
||
if (!fs.existsSync(runDir)) {
|
||
res.statusCode = 404;
|
||
res.end(JSON.stringify({ error: 'Run not found' }));
|
||
return;
|
||
}
|
||
|
||
const subPath = pathParts.slice(runDepth).join('/');
|
||
|
||
// /api/runs/:runName - list run contents (special endpoint)
|
||
if (!subPath) {
|
||
try {
|
||
const entries = fs.readdirSync(runDir, { withFileTypes: true });
|
||
const files = entries.filter(e => e.isFile()).map(e => e.name);
|
||
const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ files, directories: dirs }));
|
||
} catch (err: any) {
|
||
res.statusCode = 500;
|
||
res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
|
||
}
|
||
return;
|
||
}
|
||
|
||
// /api/runs/:runName/trajectory - list task directories
|
||
if (subPath === 'trajectory') {
|
||
const trajDir = path.join(runDir, 'trajectory');
|
||
if (!fs.existsSync(trajDir)) {
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ tasks: [] }));
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const entries = fs.readdirSync(trajDir, { withFileTypes: true });
|
||
const tasks = entries.filter(e => e.isDirectory()).map(e => e.name);
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ tasks }));
|
||
} catch (err: any) {
|
||
res.statusCode = 500;
|
||
res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
|
||
}
|
||
return;
|
||
}
|
||
|
||
// /api/runs/:runName/trajectory/:taskDir - list task contents
|
||
const subParts = subPath.split('/');
|
||
if (subParts[0] === 'trajectory' && subParts.length === 2) {
|
||
const taskDir = path.join(runDir, subPath);
|
||
if (!taskDir.startsWith(runDir)) {
|
||
res.statusCode = 403;
|
||
res.end(JSON.stringify({ error: 'Forbidden' }));
|
||
return;
|
||
}
|
||
|
||
if (!fs.existsSync(taskDir)) {
|
||
res.statusCode = 404;
|
||
res.end(JSON.stringify({ error: 'Task not found' }));
|
||
return;
|
||
}
|
||
|
||
try {
|
||
const entries = fs.readdirSync(taskDir);
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ files: entries }));
|
||
} catch (err: any) {
|
||
res.statusCode = 500;
|
||
res.end(JSON.stringify({ error: err instanceof Error ? err.message : String(err) }));
|
||
}
|
||
return;
|
||
}
|
||
|
||
// /api/runs/:runName/* - serve file
|
||
const filePath = path.join(runDir, subPath);
|
||
|
||
// Security: prevent path traversal
|
||
if (!filePath.startsWith(runDir)) {
|
||
res.statusCode = 403;
|
||
res.end(JSON.stringify({ error: 'Forbidden' }));
|
||
return;
|
||
}
|
||
|
||
if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
|
||
res.statusCode = 404;
|
||
res.end(JSON.stringify({ error: 'File not found' }));
|
||
return;
|
||
}
|
||
|
||
// Serve file with appropriate content type
|
||
const ext = path.extname(filePath).toLowerCase();
|
||
const mimeTypes: Record<string, string> = {
|
||
'.json': 'application/json',
|
||
'.jsonl': 'application/x-ndjson',
|
||
'.txt': 'text/plain; charset=utf-8',
|
||
'.png': 'image/png',
|
||
'.jpg': 'image/jpeg',
|
||
'.jpeg': 'image/jpeg',
|
||
};
|
||
|
||
const contentType = mimeTypes[ext] || 'application/octet-stream';
|
||
res.setHeader('Content-Type', contentType);
|
||
|
||
const content = fs.readFileSync(filePath);
|
||
res.end(content);
|
||
});
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 让 app 自带的静态资源在 dev/build 下都能通过稳定 URL 访问。
|
||
*
|
||
* URL:
|
||
* - /@app-assets/<AppName>/<path>
|
||
* → 文件: apps/<AppName>/assets/<path>
|
||
* - /@app-assets/<AppName>/wmr/<path>
|
||
* → 文件: apps/<AppName>/wmr/<path>
|
||
*
|
||
* Dev: 中间件直接伺服文件
|
||
* Build: generateBundle 把文件拷贝到 dist/@app-assets/
|
||
*/
|
||
function serveAppAssetsPlugin() {
|
||
const MIME: Record<string, string> = {
|
||
'.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.png': 'image/png',
|
||
'.gif': 'image/gif', '.webp': 'image/webp', '.svg': 'image/svg+xml',
|
||
'.ico': 'image/x-icon', '.mp4': 'video/mp4', '.mp3': 'audio/mpeg',
|
||
'.wav': 'audio/wav', '.ogg': 'audio/ogg', '.json': 'application/json',
|
||
'.woff': 'font/woff', '.woff2': 'font/woff2', '.ttf': 'font/ttf',
|
||
};
|
||
|
||
const PREFIX = '/@app-assets/';
|
||
let resolvedBase = '/';
|
||
|
||
function walkDir(dir: string, base: string, cb: (filePath: string, relPath: string) => void) {
|
||
for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
|
||
const full = path.join(dir, entry.name);
|
||
const rel = base ? `${base}/${entry.name}` : entry.name;
|
||
if (entry.isDirectory()) walkDir(full, rel, cb);
|
||
else if (entry.isFile()) cb(full, rel);
|
||
}
|
||
}
|
||
|
||
function resolveAppStaticFile(appName: string, relPath: string): string | null {
|
||
for (const base of ['apps', 'system']) {
|
||
const appRoot = path.join(__dirname, base, appName);
|
||
const target = relPath.startsWith('wmr/')
|
||
? path.join(appRoot, 'wmr', relPath.slice('wmr/'.length))
|
||
: path.join(appRoot, 'assets', relPath);
|
||
if (target.startsWith(appRoot) && fs.existsSync(target)) return target;
|
||
}
|
||
return null;
|
||
}
|
||
|
||
return {
|
||
name: 'serve-app-assets',
|
||
|
||
configResolved(config: { base: string }) {
|
||
resolvedBase = config.base || '/';
|
||
},
|
||
|
||
// ── Dev: 中间件伺服 ──
|
||
configureServer(server) {
|
||
server.middlewares.use((req, res, next) => {
|
||
const url = req.url;
|
||
if (!url || !url.startsWith(PREFIX)) return next();
|
||
|
||
const relPath = decodeURIComponent(url.slice(PREFIX.length).split('?')[0]);
|
||
if (relPath.includes('..') || relPath.startsWith('/')) {
|
||
res.statusCode = 403;
|
||
res.end('Forbidden');
|
||
return;
|
||
}
|
||
|
||
const slashIdx = relPath.indexOf('/');
|
||
if (slashIdx <= 0) return next();
|
||
const appName = relPath.slice(0, slashIdx);
|
||
const assetRel = relPath.slice(slashIdx + 1);
|
||
|
||
const filePath = resolveAppStaticFile(appName, assetRel);
|
||
if (!filePath || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) return next();
|
||
|
||
const ext = path.extname(filePath).toLowerCase();
|
||
res.setHeader('Content-Type', MIME[ext] || 'application/octet-stream');
|
||
res.setHeader('Cache-Control', 'max-age=31536000, immutable');
|
||
fs.createReadStream(filePath).pipe(res);
|
||
});
|
||
},
|
||
|
||
// ── Build: 拷贝到 dist ──
|
||
generateBundle(_options: unknown, bundle: Record<string, any>) {
|
||
// 子路径部署（base=/sim/）时，代码里硬编码的 `/@app-assets/` 绝对前缀
|
||
// 取不到（实际在 <base>@app-assets/）。base !== '/' 时把产物里的该前缀
|
||
// 统一改写为带 base 的版本（base='/' 为 no-op，根部署/dev 行为不变）。
|
||
if (resolvedBase !== '/') {
|
||
const want = `${resolvedBase}@app-assets/`;
|
||
for (const file of Object.values(bundle)) {
|
||
if (file.type === 'chunk' && typeof file.code === 'string') {
|
||
file.code = file.code.split(PREFIX).join(want);
|
||
} else if (file.type === 'asset' && typeof file.source === 'string') {
|
||
file.source = file.source.split(PREFIX).join(want);
|
||
}
|
||
}
|
||
}
|
||
|
||
for (const base of ['apps', 'system']) {
|
||
const baseDir = path.join(__dirname, base);
|
||
if (!fs.existsSync(baseDir)) continue;
|
||
for (const app of fs.readdirSync(baseDir, { withFileTypes: true })) {
|
||
if (!app.isDirectory()) continue;
|
||
const assetsDir = path.join(baseDir, app.name, 'assets');
|
||
if (fs.existsSync(assetsDir)) {
|
||
walkDir(assetsDir, '', (filePath, relPath) => {
|
||
(this as any).emitFile({
|
||
type: 'asset',
|
||
fileName: `@app-assets/${app.name}/${relPath}`,
|
||
source: fs.readFileSync(filePath),
|
||
});
|
||
});
|
||
}
|
||
|
||
const wmrDir = path.join(baseDir, app.name, 'wmr');
|
||
if (fs.existsSync(wmrDir)) {
|
||
walkDir(wmrDir, '', (filePath, relPath) => {
|
||
(this as any).emitFile({
|
||
type: 'asset',
|
||
fileName: `@app-assets/${app.name}/wmr/${relPath}`,
|
||
source: fs.readFileSync(filePath),
|
||
});
|
||
});
|
||
}
|
||
}
|
||
}
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Dev 环境下把 /cdn/ 映射到仓库根的 mobilegym-data/（gitignored），
|
||
* 与生产 nginx 的 alias 行为一致；生产 nginx.source.conf 里的 location /cdn/ 等价。
|
||
*/
|
||
function serveCdnPlugin() {
|
||
const MIME: Record<string, string> = {
|
||
'.webp': 'image/webp', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg',
|
||
'.png': 'image/png', '.gif': 'image/gif', '.svg': 'image/svg+xml',
|
||
'.mp4': 'video/mp4', '.webm': 'video/webm',
|
||
'.json': 'application/json',
|
||
};
|
||
const CDN_ROOT = path.resolve(__dirname, 'mobilegym-data');
|
||
const serveCdnMiddleware = (req, res, next) => {
|
||
const url = req.url || '/';
|
||
const rel = decodeURIComponent(url.split('?')[0]).replace(/^\/+/, '');
|
||
if (!rel || rel.includes('..')) return next();
|
||
|
||
const filePath = path.join(CDN_ROOT, rel);
|
||
if (!filePath.startsWith(CDN_ROOT) || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
|
||
return next();
|
||
}
|
||
|
||
const ext = path.extname(filePath).toLowerCase();
|
||
res.setHeader('Content-Type', MIME[ext] || 'application/octet-stream');
|
||
res.setHeader('Cache-Control', 'public, max-age=2592000, immutable');
|
||
fs.createReadStream(filePath).pipe(res);
|
||
};
|
||
|
||
return {
|
||
name: 'serve-cdn',
|
||
configureServer(server) {
|
||
server.middlewares.use('/cdn/', serveCdnMiddleware);
|
||
},
|
||
configurePreviewServer(server) {
|
||
server.middlewares.use('/cdn/', serveCdnMiddleware);
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 把 apps/Map/sw/ 暴露到根路径：
|
||
* /map-sw.js → apps/Map/sw/map-sw.js
|
||
* /map-cache/<file> → apps/Map/sw/<file>（legacy dev fallback）
|
||
* /map-vector-cache/<file> → apps/Map/sw/vector/<file>（legacy dev fallback）
|
||
* Service Worker 注册要求 SW 文件能拿到根 scope，所以这两个路径必须在站点根。
|
||
* 大型地图缓存走 /cdn/map/...（mobilegym-data 或生产 CDN），不要打进 App 源码/构建产物。
|
||
*
|
||
* 生产 build 只把 SW 文件和小 bootstrap manifest 复制到 dist；地图缓存由 CDN 提供。
|
||
*/
|
||
function mapServiceWorkerPlugin() {
|
||
const SW_ROOT = path.resolve(__dirname, 'apps/Map/sw');
|
||
const MIME: Record<string, string> = {
|
||
'.js': 'application/javascript',
|
||
'.json': 'application/json',
|
||
'.png': 'image/png',
|
||
'.jpg': 'image/jpeg',
|
||
'.jpeg': 'image/jpeg',
|
||
'.webp': 'image/webp',
|
||
'.css': 'text/css',
|
||
'.woff': 'font/woff',
|
||
'.woff2': 'font/woff2',
|
||
'.bin': 'application/octet-stream',
|
||
};
|
||
|
||
const sendFile = (res: any, filePath: string) => {
|
||
const ext = path.extname(filePath).toLowerCase();
|
||
res.setHeader('Content-Type', MIME[ext] || 'application/octet-stream');
|
||
res.setHeader('Cache-Control', 'no-cache');
|
||
res.setHeader('Service-Worker-Allowed', '/');
|
||
fs.createReadStream(filePath).pipe(res);
|
||
};
|
||
|
||
const swMiddleware = (req: any, res: any, next: any) => {
|
||
if (req.url && req.url.split('?')[0] === '/map-sw.js') {
|
||
const filePath = path.join(SW_ROOT, 'map-sw.js');
|
||
if (fs.existsSync(filePath)) return sendFile(res, filePath);
|
||
}
|
||
next();
|
||
};
|
||
|
||
const makeCacheMiddleware = (prefix: string, root: string) => (req: any, res: any, next: any) => {
|
||
const url = req.url || '/';
|
||
const rel = decodeURIComponent(url.split('?')[0]).replace(new RegExp(`^${prefix}`), '');
|
||
if (!rel || rel.includes('..')) return next();
|
||
const filePath = path.join(root, rel);
|
||
if (!filePath.startsWith(root) || !fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
|
||
// 显式 404，避免落到 Vite 的 SPA fallback 把 index.html 当成缓存文件返回
|
||
res.statusCode = 404;
|
||
res.setHeader('Content-Type', 'text/plain');
|
||
res.end('not found');
|
||
return;
|
||
}
|
||
sendFile(res, filePath);
|
||
};
|
||
const rasterCacheMiddleware = makeCacheMiddleware('/map-cache/', SW_ROOT);
|
||
const vectorCacheMiddleware = makeCacheMiddleware('/map-vector-cache/', path.join(SW_ROOT, 'vector'));
|
||
|
||
return {
|
||
name: 'map-service-worker',
|
||
configureServer(server: any) {
|
||
server.middlewares.use(swMiddleware);
|
||
server.middlewares.use('/map-cache/', rasterCacheMiddleware);
|
||
server.middlewares.use('/map-vector-cache/', vectorCacheMiddleware);
|
||
},
|
||
configurePreviewServer(server: any) {
|
||
server.middlewares.use(swMiddleware);
|
||
server.middlewares.use('/map-cache/', rasterCacheMiddleware);
|
||
server.middlewares.use('/map-vector-cache/', vectorCacheMiddleware);
|
||
},
|
||
closeBundle() {
|
||
// 生产 build：只复制 SW 和小 bootstrap manifest，缓存资产走 /cdn/map/...
|
||
const outDir = path.resolve(__dirname, 'dist');
|
||
if (!fs.existsSync(outDir)) return;
|
||
const swSrc = path.join(SW_ROOT, 'map-sw.js');
|
||
if (fs.existsSync(swSrc)) fs.copyFileSync(swSrc, path.join(outDir, 'map-sw.js'));
|
||
const bootstrapSrc = path.join(SW_ROOT, 'vector', 'bootstrap-manifest.json');
|
||
if (fs.existsSync(bootstrapSrc)) {
|
||
const bootstrapOutDir = path.join(outDir, 'map-vector-cache');
|
||
fs.mkdirSync(bootstrapOutDir, { recursive: true });
|
||
fs.copyFileSync(bootstrapSrc, path.join(bootstrapOutDir, 'bootstrap-manifest.json'));
|
||
}
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* 用 Tailwind CLI (Rust 原生) 代替 JS 插件生成 CSS。
|
||
* JS 插件需 ~40 秒，CLI 只需 ~1 秒。
|
||
*
|
||
* Dev: 先同步 build 一次确保 index.css 存在，再后台 --watch
|
||
* Build: 同步 build 一次即可
|
||
*/
|
||
function tailwindCliPlugin() {
|
||
const bin = path.join(__dirname, 'node_modules', '.bin', 'tailwindcss');
|
||
const input = path.join(__dirname, 'app.css');
|
||
const output = path.join(__dirname, 'index.css');
|
||
const isWin = process.platform === 'win32';
|
||
let child: ChildProcess | null = null;
|
||
let stopping = false;
|
||
let restartCount = 0;
|
||
let lastStartTime = 0;
|
||
|
||
const MAX_FAST_RESTARTS = 5;
|
||
const FAST_EXIT_THRESHOLD_MS = 3000;
|
||
|
||
function buildSync() {
|
||
execFileSync(bin, ['-i', input, '-o', output], {
|
||
cwd: __dirname,
|
||
stdio: 'pipe',
|
||
shell: isWin,
|
||
});
|
||
}
|
||
|
||
function startWatch() {
|
||
if (stopping) return;
|
||
|
||
const now = Date.now();
|
||
if (now - lastStartTime < FAST_EXIT_THRESHOLD_MS) {
|
||
restartCount++;
|
||
} else {
|
||
restartCount = 0;
|
||
}
|
||
|
||
if (restartCount >= MAX_FAST_RESTARTS) {
|
||
console.error(
|
||
`\x1b[31m[tailwind] ✗ watcher crashed ${MAX_FAST_RESTARTS} times in a row, giving up.\x1b[0m\n` +
|
||
` CSS will NOT auto-update. Restart the dev server to retry.`
|
||
);
|
||
return;
|
||
}
|
||
|
||
lastStartTime = now;
|
||
child = spawn(bin, ['-i', input, '-o', output, '--watch=always'], {
|
||
cwd: __dirname,
|
||
stdio: ['ignore', 'pipe', 'pipe'],
|
||
shell: isWin,
|
||
});
|
||
|
||
const pid = child.pid;
|
||
console.log(`\x1b[36m[tailwind]\x1b[0m watcher started (pid ${pid})`);
|
||
|
||
child.stderr?.on('data', (d: Buffer) => {
|
||
const msg = d.toString().trim();
|
||
if (msg && !msg.includes('Done in')) console.log(`\x1b[36m[tailwind]\x1b[0m ${msg}`);
|
||
});
|
||
|
||
child.on('exit', (code, signal) => {
|
||
child = null;
|
||
if (stopping) return;
|
||
const delay = Math.min(1000 * 2 ** restartCount, 10000);
|
||
console.warn(
|
||
`\x1b[33m[tailwind] ⚠ watcher exited unexpectedly\x1b[0m (code=${code}, signal=${signal}), restarting in ${delay}ms...`
|
||
);
|
||
setTimeout(startWatch, delay);
|
||
});
|
||
|
||
child.on('error', (err) => {
|
||
console.error(`\x1b[31m[tailwind] ✗ watcher error:\x1b[0m`, err.message);
|
||
});
|
||
}
|
||
|
||
function stopWatch() {
|
||
stopping = true;
|
||
if (!child) return;
|
||
child.kill();
|
||
child = null;
|
||
}
|
||
|
||
return {
|
||
name: 'tailwind-cli',
|
||
|
||
buildStart() {
|
||
buildSync();
|
||
},
|
||
|
||
configureServer(server: any) {
|
||
buildSync();
|
||
startWatch();
|
||
server.httpServer?.on('close', stopWatch);
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Unified API Gateway (single same-origin entry)
|
||
*
|
||
* Motivation:
|
||
* - Avoid sprinkling many bespoke /api/* proxy middlewares as apps grow
|
||
* - Provide one stable entry for ALL apps: /api/gw/<service>/<path...>
|
||
*
|
||
* How to extend:
|
||
* - Add/adjust service config in this function (no new middleware needed)
|
||
*/
|
||
function apiGatewayPlugin(mode: string) {
|
||
const env = loadEnv(mode, process.cwd(), '');
|
||
|
||
const cfg = {
|
||
gateway: {
|
||
// Optional allowlist for generic fetch proxy (comma separated hosts). Empty = allow all.
|
||
allowHosts: (env.VITE_GW_ALLOW_HOSTS || '').split(',').map(s => s.trim()).filter(Boolean),
|
||
},
|
||
} as const;
|
||
|
||
const isAllowedHost = (host: string) => {
|
||
const allow = cfg.gateway.allowHosts;
|
||
if (!allow.length) return true; // default: allow all (dev tool)
|
||
return allow.includes(host);
|
||
};
|
||
|
||
const readJsonBody = (req): Promise<any> =>
|
||
new Promise((resolve, reject) => {
|
||
let data = '';
|
||
req.on('data', (chunk) => (data += chunk));
|
||
req.on('end', () => {
|
||
if (!data) return resolve({});
|
||
try {
|
||
resolve(JSON.parse(data));
|
||
} catch (e) {
|
||
reject(e);
|
||
}
|
||
});
|
||
req.on('error', reject);
|
||
});
|
||
|
||
// ---------------- Cookie jar (server-side, per session) ----------------
|
||
type CookieEntry = { value: string; expiresAt?: number };
|
||
type CookieJar = Map<string, Map<string, CookieEntry>>; // host -> name -> entry
|
||
const COOKIE_JARS: Map<string, CookieJar> = (globalThis as any).__GW_COOKIE_JARS__ || new Map();
|
||
(globalThis as any).__GW_COOKIE_JARS__ = COOKIE_JARS;
|
||
|
||
// ---------------- Proxy 404 cache (avoid repeated upstream calls for dead URLs) ----------------
|
||
const PROXY_404_CACHE_MAX = 500;
|
||
const PROXY_404_TTL_MS = 5 * 60 * 1000; // 5 min
|
||
const PROXY_404_CACHE: Map<string, number> = (globalThis as any).__GW_PROXY_404_CACHE__ || new Map();
|
||
(globalThis as any).__GW_PROXY_404_CACHE__ = PROXY_404_CACHE;
|
||
|
||
const proxy404CacheGet = (url: string): boolean => {
|
||
const expiresAt = PROXY_404_CACHE.get(url);
|
||
if (expiresAt == null) return false;
|
||
if (Date.now() > expiresAt) {
|
||
PROXY_404_CACHE.delete(url);
|
||
return false;
|
||
}
|
||
return true;
|
||
};
|
||
|
||
const proxy404CacheSet = (url: string) => {
|
||
PROXY_404_CACHE.set(url, Date.now() + PROXY_404_TTL_MS);
|
||
if (PROXY_404_CACHE.size > PROXY_404_CACHE_MAX) {
|
||
const now = Date.now();
|
||
for (const [k, exp] of PROXY_404_CACHE.entries()) {
|
||
if (exp <= now) PROXY_404_CACHE.delete(k);
|
||
}
|
||
}
|
||
};
|
||
|
||
const getSessionId = (req) => {
|
||
const h = req.headers?.['x-gw-session'];
|
||
if (!h) return 'anon';
|
||
if (Array.isArray(h)) return h[0] || 'anon';
|
||
return String(h);
|
||
};
|
||
|
||
const getJar = (sessionId: string): CookieJar => {
|
||
let jar = COOKIE_JARS.get(sessionId);
|
||
if (!jar) {
|
||
jar = new Map();
|
||
COOKIE_JARS.set(sessionId, jar);
|
||
}
|
||
return jar;
|
||
};
|
||
|
||
const parseSetCookie = (setCookie: string): { name: string; value: string; expiresAt?: number } | null => {
|
||
const parts = setCookie.split(';').map(s => s.trim());
|
||
const [nv, ...attrs] = parts;
|
||
const eq = nv.indexOf('=');
|
||
if (eq <= 0) return null;
|
||
const name = nv.slice(0, eq);
|
||
const value = nv.slice(eq + 1);
|
||
let expiresAt: number | undefined;
|
||
for (const a of attrs) {
|
||
const [k, v] = a.split('=');
|
||
const key = (k || '').toLowerCase();
|
||
const val = (v || '').trim();
|
||
if (key === 'max-age') {
|
||
const sec = Number(val);
|
||
if (!Number.isNaN(sec)) expiresAt = Date.now() + sec * 1000;
|
||
} else if (key === 'expires') {
|
||
const t = Date.parse(val);
|
||
if (!Number.isNaN(t)) expiresAt = t;
|
||
}
|
||
}
|
||
return { name, value, expiresAt };
|
||
};
|
||
|
||
const storeCookies = (sessionId: string, host: string, setCookies: string[]) => {
|
||
if (!setCookies?.length) return;
|
||
const jar = getJar(sessionId);
|
||
let hostMap = jar.get(host);
|
||
if (!hostMap) {
|
||
hostMap = new Map();
|
||
jar.set(host, hostMap);
|
||
}
|
||
for (const sc of setCookies) {
|
||
const parsed = parseSetCookie(sc);
|
||
if (!parsed) continue;
|
||
// Expired -> delete
|
||
if (parsed.expiresAt != null && parsed.expiresAt <= Date.now()) {
|
||
hostMap.delete(parsed.name);
|
||
continue;
|
||
}
|
||
hostMap.set(parsed.name, { value: parsed.value, expiresAt: parsed.expiresAt });
|
||
}
|
||
};
|
||
|
||
const buildCookieHeader = (sessionId: string, host: string): string | undefined => {
|
||
const jar = getJar(sessionId);
|
||
const hostMap = jar.get(host);
|
||
if (!hostMap) return undefined;
|
||
const now = Date.now();
|
||
const pairs: string[] = [];
|
||
for (const [name, entry] of hostMap.entries()) {
|
||
if (entry.expiresAt != null && entry.expiresAt <= now) {
|
||
hostMap.delete(name);
|
||
continue;
|
||
}
|
||
pairs.push(`${name}=${entry.value}`);
|
||
}
|
||
return pairs.length ? pairs.join('; ') : undefined;
|
||
};
|
||
|
||
const forwardHeaders = (upstreamHeaders: Headers, res, allowList?: string[]) => {
|
||
// Forward a safe subset of headers. (Hop-by-hop headers must not be forwarded.)
|
||
const allow = allowList ?? [
|
||
'content-type',
|
||
'content-length',
|
||
'content-encoding',
|
||
'cache-control',
|
||
'expires',
|
||
'etag',
|
||
'last-modified',
|
||
'vary',
|
||
];
|
||
for (const k of allow) {
|
||
const v = upstreamHeaders.get(k);
|
||
if (v) res.setHeader(k, v);
|
||
}
|
||
};
|
||
|
||
const handler = async (req, res) => {
|
||
try {
|
||
const incoming = new URL(req.url || '/', `http://${req.headers.host}`);
|
||
/**
|
||
* Path parsing note (IMPORTANT):
|
||
* When mounted via `server.middlewares.use('/api/gw', handler)`, Connect will strip the mount prefix.
|
||
* So `req.url` becomes `/fetch` instead of `/api/gw/fetch`.
|
||
* We support BOTH forms:
|
||
* - /api/gw/<service>/<rest...>
|
||
* - /<service>/<rest...> (prefix stripped)
|
||
*/
|
||
const parts = incoming.pathname.split('/').filter(Boolean);
|
||
const hasFullPrefix = parts[0] === 'api' && parts[1] === 'gw';
|
||
const service = hasFullPrefix ? parts[2] : parts[0];
|
||
const restPath = '/' + (hasFullPrefix ? parts.slice(3) : parts.slice(1)).join('/');
|
||
|
||
if (!service) {
|
||
res.statusCode = 400;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: 'Missing service in path: /api/gw/<service>/...' }));
|
||
return;
|
||
}
|
||
|
||
// ---- Generic fetch proxy: POST /api/gw/fetch { url, method, headers, body }
|
||
// This is the universal escape hatch for CORS. Apps should prefer this via os/NetworkService.
|
||
if (service === 'fetch') {
|
||
if (req.method !== 'POST') {
|
||
res.statusCode = 405;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: 'Method not allowed. Use POST.' }));
|
||
return;
|
||
}
|
||
const payload = await readJsonBody(req);
|
||
const target = payload?.url;
|
||
if (!target || typeof target !== 'string') {
|
||
res.statusCode = 400;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: 'Missing payload.url' }));
|
||
return;
|
||
}
|
||
const u = new URL(target);
|
||
if (!(u.protocol === 'https:' || u.protocol === 'http:')) {
|
||
res.statusCode = 400;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: 'Only http/https protocols are allowed' }));
|
||
return;
|
||
}
|
||
if (!isAllowedHost(u.host)) {
|
||
res.statusCode = 403;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: `Host not allowed: ${u.host}` }));
|
||
return;
|
||
}
|
||
|
||
const sessionId = getSessionId(req);
|
||
const method = (payload.method || 'GET').toUpperCase();
|
||
const headers = payload.headers && typeof payload.headers === 'object' ? payload.headers : undefined;
|
||
const body = typeof payload.body === 'string' ? payload.body : undefined;
|
||
|
||
// Stream proxy to avoid buffering large responses in memory.
|
||
const controller = new AbortController();
|
||
const abortUpstream = () => {
|
||
try {
|
||
controller.abort();
|
||
} catch {
|
||
// ignore
|
||
}
|
||
};
|
||
res.on('close', abortUpstream);
|
||
res.on('error', abortUpstream);
|
||
|
||
let upstreamResp: Response;
|
||
try {
|
||
// Avoid upstream compression to prevent content-encoding/body mismatch.
|
||
// (Some fetch implementations may transparently decompress.)
|
||
const upstreamHeaders = { ...(headers || {}) };
|
||
if (!('accept-encoding' in Object.keys(upstreamHeaders).reduce((m, k) => ((m[k.toLowerCase()] = upstreamHeaders[k]), m), {} as any))) {
|
||
upstreamHeaders['accept-encoding'] = 'identity';
|
||
}
|
||
// Cookie jar (only if caller didn't explicitly set Cookie)
|
||
const hasCookie = Object.keys(upstreamHeaders).some(k => k.toLowerCase() === 'cookie');
|
||
if (!hasCookie) {
|
||
const cookie = buildCookieHeader(sessionId, u.host);
|
||
if (cookie) upstreamHeaders['cookie'] = cookie;
|
||
}
|
||
|
||
upstreamResp = await fetch(u.toString(), {
|
||
method,
|
||
headers: upstreamHeaders,
|
||
body,
|
||
signal: controller.signal,
|
||
});
|
||
} catch (e: any) {
|
||
// Client closed early -> fetch may reject with AbortError, treat as normal.
|
||
const name = e?.name || '';
|
||
if (name === 'AbortError' || controller.signal.aborted) {
|
||
if (!res.writableEnded) res.end();
|
||
return;
|
||
}
|
||
throw e;
|
||
}
|
||
|
||
res.statusCode = upstreamResp.status;
|
||
// IMPORTANT:
|
||
// Do NOT forward content-encoding/content-length here.
|
||
// Upstream fetch may transparently decompress while keeping headers,
|
||
// which would make browsers fail with "Failed to fetch".
|
||
forwardHeaders(upstreamResp.headers, res, [
|
||
'content-type',
|
||
'cache-control',
|
||
'expires',
|
||
'etag',
|
||
'last-modified',
|
||
'vary',
|
||
]);
|
||
|
||
if (!upstreamResp.body) {
|
||
res.end();
|
||
return;
|
||
}
|
||
|
||
// Store Set-Cookie into jar (Node fetch provides getSetCookie in recent versions)
|
||
const getSetCookie = (upstreamResp.headers as any).getSetCookie?.bind(upstreamResp.headers);
|
||
const setCookies: string[] = typeof getSetCookie === 'function' ? getSetCookie() : [];
|
||
if (setCookies?.length) storeCookies(sessionId, u.host, setCookies);
|
||
|
||
// Node 18+ supports web streams; convert to Node stream for piping.
|
||
const nodeStream = Readable.fromWeb(upstreamResp.body as any);
|
||
nodeStream.on('error', (e: any) => {
|
||
// AbortError is expected when client disconnects; don't crash dev server.
|
||
const name = e?.name || '';
|
||
if (name === 'AbortError' || controller.signal.aborted) return;
|
||
console.warn('[gw/fetch] stream error:', e?.message || e);
|
||
});
|
||
res.on('close', () => {
|
||
// Ensure stream is destroyed to stop work.
|
||
try {
|
||
nodeStream.destroy();
|
||
} catch {
|
||
// ignore
|
||
}
|
||
});
|
||
nodeStream.pipe(res);
|
||
return;
|
||
}
|
||
|
||
// ---- Generic streaming proxy: /api/gw/proxy?url=https://...
|
||
// For non-string bodies (FormData/Blob/ArrayBuffer/ReadableStream) we tunnel request body through gateway.
|
||
if (service === 'proxy') {
|
||
const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
|
||
|
||
const sessionId = getSessionId(req);
|
||
const target = incoming.searchParams.get('url');
|
||
if (!target) {
|
||
res.statusCode = 400;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: 'Missing query param: url' }));
|
||
return;
|
||
}
|
||
const u = new URL(target);
|
||
if (!(u.protocol === 'https:' || u.protocol === 'http:')) {
|
||
res.statusCode = 400;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: 'Only http/https protocols are allowed' }));
|
||
return;
|
||
}
|
||
if (!isAllowedHost(u.host)) {
|
||
res.statusCode = 403;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: `Host not allowed: ${u.host}` }));
|
||
return;
|
||
}
|
||
|
||
const method = (req.method || 'GET').toUpperCase();
|
||
if (method === 'GET' && proxy404CacheGet(u.toString())) {
|
||
res.statusCode = 404;
|
||
res.end();
|
||
return;
|
||
}
|
||
|
||
const controller = new AbortController();
|
||
const abortUpstream = () => {
|
||
try {
|
||
controller.abort();
|
||
} catch {
|
||
// ignore
|
||
}
|
||
};
|
||
res.on('close', abortUpstream);
|
||
res.on('error', abortUpstream);
|
||
|
||
// Build upstream headers from incoming request headers.
|
||
// Strip hop-by-hop, browser-internal, and localhost-leaking headers so
|
||
// upstream CDNs (e.g. pbs.twimg.com) see a clean server-side request.
|
||
const upstreamHeaders: Record<string, string> = {};
|
||
const skipHeaders = new Set([
|
||
'connection',
|
||
'keep-alive',
|
||
'proxy-authenticate',
|
||
'proxy-authorization',
|
||
'te',
|
||
'trailer',
|
||
'transfer-encoding',
|
||
'upgrade',
|
||
'host',
|
||
// Browser-internal — meaningless/misleading for server-side fetch
|
||
'origin',
|
||
'referer',
|
||
'sec-fetch-dest',
|
||
'sec-fetch-mode',
|
||
'sec-fetch-site',
|
||
'sec-fetch-user',
|
||
'x-gw-session',
|
||
]);
|
||
for (const [k, v] of Object.entries(req.headers || {})) {
|
||
const key = k.toLowerCase();
|
||
if (skipHeaders.has(key)) continue;
|
||
if (typeof v === 'string') upstreamHeaders[key] = v;
|
||
else if (Array.isArray(v)) upstreamHeaders[key] = v.join(', ');
|
||
}
|
||
// Force identity encoding so upstream returns uncompressed body.
|
||
// This makes content-length safe to forward (no compress/decompress mismatch).
|
||
upstreamHeaders['accept-encoding'] = 'identity';
|
||
// Cookie jar if no explicit cookie
|
||
if (!('cookie' in upstreamHeaders)) {
|
||
const cookie = buildCookieHeader(sessionId, u.host);
|
||
if (cookie) upstreamHeaders['cookie'] = cookie;
|
||
}
|
||
|
||
const canHaveBody = method !== 'GET' && method !== 'HEAD';
|
||
|
||
let upstreamResp: Response;
|
||
try {
|
||
const bodyWeb = canHaveBody && (Readable as any).toWeb
|
||
? (Readable as any).toWeb(req) : undefined;
|
||
const fetchOpts: any = {
|
||
method,
|
||
headers: upstreamHeaders,
|
||
signal: controller.signal,
|
||
};
|
||
if (bodyWeb) {
|
||
fetchOpts.body = bodyWeb;
|
||
fetchOpts.duplex = 'half';
|
||
}
|
||
try {
|
||
upstreamResp = await fetch(u.toString(), fetchOpts);
|
||
} catch (e: any) {
|
||
// Retry once for transient network errors.
|
||
const code = e?.cause?.code || e?.code || '';
|
||
const msg = e?.cause?.message || e?.message || String(e);
|
||
const canRetry = typeof code === 'string' && (
|
||
code.includes('UND_ERR_CONNECT') ||
|
||
code.includes('UND_ERR_SOCKET') ||
|
||
code.includes('UND_ERR_HEADERS_TIMEOUT') ||
|
||
code.includes('UND_ERR_BODY_TIMEOUT') ||
|
||
code.includes('ECONNRESET') ||
|
||
code.includes('EPIPE') ||
|
||
code.includes('ETIMEDOUT') ||
|
||
code.includes('ENOTFOUND') ||
|
||
code.includes('EAI_AGAIN')
|
||
);
|
||
|
||
if (canRetry && !controller.signal.aborted) {
|
||
console.warn('[gw/proxy] upstream fetch failed, retrying once:', {
|
||
url: u.toString(),
|
||
code,
|
||
message: msg,
|
||
});
|
||
await sleep(120);
|
||
upstreamResp = await fetch(u.toString(), fetchOpts);
|
||
} else {
|
||
throw e;
|
||
}
|
||
}
|
||
} catch (e: any) {
|
||
const name = e?.name || '';
|
||
if (name === 'AbortError' || controller.signal.aborted) {
|
||
if (!res.writableEnded) res.end();
|
||
return;
|
||
}
|
||
// Important: proxy requests are often used for images/videos; callers can't easily read the JSON error body.
|
||
// Log the full error on server side to help debug intermittent upstream failures.
|
||
const code = e?.cause?.code || e?.code || '';
|
||
const msg = e?.cause?.message || e?.message || String(e);
|
||
console.warn('[gw/proxy] upstream fetch error:', {
|
||
url: u.toString(),
|
||
method,
|
||
code,
|
||
message: msg,
|
||
});
|
||
res.statusCode = 502;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: msg, code, url: u.toString() }));
|
||
return;
|
||
}
|
||
|
||
res.statusCode = upstreamResp.status;
|
||
if (method === 'GET' && upstreamResp.status === 404) {
|
||
proxy404CacheSet(u.toString());
|
||
}
|
||
// Node.js 22+ auto-decompresses gzip/deflate responses, so the
|
||
// original content-length from upstream refers to the *compressed*
|
||
// size while the body we pipe is already decompressed. Forwarding
|
||
// that stale content-length causes the browser to truncate the
|
||
// response. Skip it when content-encoding is present.
|
||
const upstreamEncoded = !!upstreamResp.headers.get('content-encoding');
|
||
const proxyAllowHeaders = [
|
||
'content-type',
|
||
...(upstreamEncoded ? [] : ['content-length']),
|
||
'content-range',
|
||
'accept-ranges',
|
||
'cache-control',
|
||
'expires',
|
||
'etag',
|
||
'last-modified',
|
||
'vary',
|
||
'content-disposition',
|
||
'location',
|
||
];
|
||
forwardHeaders(upstreamResp.headers, res, proxyAllowHeaders);
|
||
|
||
// Store cookies
|
||
const getSetCookie = (upstreamResp.headers as any).getSetCookie?.bind(upstreamResp.headers);
|
||
const setCookies: string[] = typeof getSetCookie === 'function' ? getSetCookie() : [];
|
||
if (setCookies?.length) storeCookies(sessionId, u.host, setCookies);
|
||
|
||
if (!upstreamResp.body) {
|
||
res.end();
|
||
return;
|
||
}
|
||
|
||
let nodeStream: any;
|
||
try {
|
||
nodeStream = Readable.fromWeb(upstreamResp.body as any);
|
||
} catch (e: any) {
|
||
console.warn('[gw/proxy] Readable.fromWeb failed:', e?.message || e);
|
||
res.end();
|
||
return;
|
||
}
|
||
nodeStream.on('error', (e: any) => {
|
||
const name = e?.name || '';
|
||
if (name === 'AbortError' || controller.signal.aborted) return;
|
||
console.warn('[gw/proxy] stream error:', e?.message || e);
|
||
});
|
||
res.on('close', () => {
|
||
try {
|
||
nodeStream.destroy();
|
||
} catch {}
|
||
});
|
||
nodeStream.pipe(res);
|
||
return;
|
||
}
|
||
|
||
res.statusCode = 404;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: `Unknown service: ${service}` }));
|
||
} catch (err: any) {
|
||
res.statusCode = 500;
|
||
res.setHeader('Content-Type', 'application/json');
|
||
res.end(JSON.stringify({ error: err?.message || String(err) }));
|
||
}
|
||
};
|
||
|
||
return {
|
||
name: 'api-gateway',
|
||
configureServer(server) {
|
||
server.middlewares.use('/api/gw', handler);
|
||
server.middlewares.use('/api/gw/', handler);
|
||
},
|
||
configurePreviewServer(server) {
|
||
server.middlewares.use('/api/gw', handler);
|
||
server.middlewares.use('/api/gw/', handler);
|
||
},
|
||
};
|
||
}
|
||
|
||
/**
|
||
* Generate a human-readable label from filename
|
||
* Format: "appName [Type]" or "appName [Type] (suffix)"
|
||
*/
|
||
function generateLabel(filename, type) {
|
||
// Remove extension
|
||
let name = filename.replace(/\.(jsonl?|json)$/, '');
|
||
|
||
// Extract app name (everything before the first type indicator)
|
||
const typePatterns = [
|
||
/_?action_tasks_?/gi,
|
||
/_?nav_graph_?/gi,
|
||
/_?data_graph_?/gi,
|
||
];
|
||
|
||
let appName = name;
|
||
let suffix = '';
|
||
|
||
// Find the first type pattern match and split there
|
||
for (const pattern of typePatterns) {
|
||
const match = name.match(pattern);
|
||
if (match) {
|
||
const idx = name.search(pattern);
|
||
appName = name.slice(0, idx).replace(/_+$/, '');
|
||
suffix = name.slice(idx + match[0].length).replace(/^_+|_+$/g, '');
|
||
break;
|
||
}
|
||
}
|
||
|
||
// Build label: "appName [Type] (suffix)"
|
||
const parts: string[] = [];
|
||
if (appName) parts.push(appName);
|
||
|
||
// Add type indicator
|
||
if (type === 'nav_graph') {
|
||
parts.push('[Schema]');
|
||
} else if (type === 'data_graph') {
|
||
parts.push('[Data]');
|
||
} else if (type === 'action_tasks') {
|
||
// Determine if it's data or schema based on suffix
|
||
if (suffix === 'data') {
|
||
parts.push('[Data]');
|
||
suffix = ''; // consumed
|
||
} else {
|
||
parts.push('[Schema]');
|
||
}
|
||
}
|
||
|
||
// Add remaining suffix if any
|
||
if (suffix) {
|
||
const cleanSuffix = suffix.replace(/_/g, ' ').replace(/\s+/g, ' ').trim();
|
||
if (cleanSuffix) parts.push(`(${cleanSuffix})`);
|
||
}
|
||
|
||
// Fallback if nothing was extracted
|
||
if (parts.length === 0) {
|
||
parts.push(filename);
|
||
}
|
||
|
||
return parts.join(' ');
|
||
}
|
||
|
||
export default defineConfig(({ mode }) => {
|
||
return {
|
||
// 默认根路径部署（mobilegym.dev/、本地 dev、bench_env 都用 '/'）。
|
||
// demo 分支的 GitHub Pages 部署把模拟器放在 /sim/ 子路径，通过
|
||
// VITE_BASE=/sim/ 覆盖，使打包出的资源 URL 自动带前缀。
|
||
base: process.env.VITE_BASE || '/',
|
||
server: {
|
||
port: 3000,
|
||
host: '0.0.0.0',
|
||
allowedHosts: true as const,
|
||
watch: {
|
||
ignored: [
|
||
'**/runs/**',
|
||
'**/runs-old/**',
|
||
'**/runs-*/**',
|
||
'**/mobilegym-data/**',
|
||
],
|
||
},
|
||
},
|
||
plugins: [
|
||
tailwindCliPlugin(),
|
||
react(),
|
||
accessLogPlugin(),
|
||
serveAppAssetsPlugin(),
|
||
serveCdnPlugin(),
|
||
mapServiceWorkerPlugin(),
|
||
listPublicFilesPlugin(),
|
||
fileSystemPlugin(),
|
||
runsExplorerPlugin(),
|
||
apiGatewayPlugin(mode),
|
||
],
|
||
resolve: {
|
||
alias: {
|
||
'@': path.resolve(__dirname, '.'),
|
||
},
|
||
dedupe: ['react', 'react-dom', 'lucide-react'],
|
||
},
|
||
// @sqlite.org/sqlite-wasm 在内部用 `new URL("sqlite3.wasm", import.meta.url)`
|
||
// 定位它的 WASM 二进制。Vite 的 dep optimizer 会把包重打包到 .vite/deps/，
|
||
// 但不会顺带把 sqlite3.wasm 复制过去；导致运行时 import.meta.url 指向 .vite/deps
|
||
// 时 fetch sqlite3.wasm 拿到 SPA fallback 的 HTML。`exclude` 阻止预打包，
|
||
// import.meta.url 就回到 node_modules/.../dist/，wasm 能正确就近加载。
|
||
optimizeDeps: {
|
||
exclude: ['@sqlite.org/sqlite-wasm'],
|
||
},
|
||
};
|
||
});
|