real2sim-platform/server/assetStore.ts
2026-06-04 12:28:08 +08:00

163 lines
4.7 KiB
TypeScript

import { access, mkdir, writeFile } from 'node:fs/promises'
import path from 'node:path'
import type { StoredTask } from './taskStore.js'
type AssetSpec = {
remoteKey: 'rendered_image_url' | 'pbr_model_url' | 'base_model_url' | 'model_url'
localKey: 'local_rendered_image_url' | 'local_pbr_model_url' | 'local_base_model_url' | 'local_model_url'
baseName: string
fallbackExtension: string
}
const assetSpecs = [
{
remoteKey: 'rendered_image_url',
localKey: 'local_rendered_image_url',
baseName: 'render',
fallbackExtension: '.png',
},
{
remoteKey: 'pbr_model_url',
localKey: 'local_pbr_model_url',
baseName: 'pbr',
fallbackExtension: '.glb',
},
{
remoteKey: 'base_model_url',
localKey: 'local_base_model_url',
baseName: 'base',
fallbackExtension: '.glb',
},
{
remoteKey: 'model_url',
localKey: 'local_model_url',
baseName: 'model',
fallbackExtension: '.glb',
},
] as const satisfies readonly AssetSpec[]
export const assetRoot = process.env.REAL2SIM_ASSET_ROOT
? path.resolve(process.env.REAL2SIM_ASSET_ROOT)
: path.join(process.cwd(), '.data', 'assets')
function safePathSegment(value: string) {
return value.replace(/[^a-zA-Z0-9._-]/g, '_')
}
function extensionFromUrl(url: string) {
try {
const extension = path.extname(new URL(url).pathname).toLowerCase()
return extension || undefined
} catch {
return undefined
}
}
function extensionFromContentType(contentType: string | null) {
if (!contentType) return undefined
if (contentType.includes('model/gltf-binary')) return '.glb'
if (contentType.includes('image/png')) return '.png'
if (contentType.includes('image/jpeg')) return '.jpg'
if (contentType.includes('image/webp')) return '.webp'
return undefined
}
async function fileExists(filePath: string) {
try {
await access(filePath)
return true
} catch {
return false
}
}
function localAssetUrl(taskId: string, fileName: string) {
return `/assets/${encodeURIComponent(safePathSegment(taskId))}/${encodeURIComponent(fileName)}`
}
async function cacheRemoteAsset(taskId: string, remoteUrl: string, baseName: string, fallbackExtension: string) {
const parsed = new URL(remoteUrl)
if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
return undefined
}
const extension = extensionFromUrl(remoteUrl) || fallbackExtension
const fileName = `${baseName}${extension}`
const assetDir = path.join(assetRoot, safePathSegment(taskId))
const filePath = path.join(assetDir, fileName)
if (await fileExists(filePath)) {
return localAssetUrl(taskId, fileName)
}
const response = await fetch(remoteUrl)
if (!response.ok) {
throw new Error(`Asset download failed with HTTP ${response.status}`)
}
const contentTypeExtension = extensionFromContentType(response.headers.get('content-type'))
const resolvedFileName = contentTypeExtension && extension === fallbackExtension ? `${baseName}${contentTypeExtension}` : fileName
const resolvedFilePath = path.join(assetDir, resolvedFileName)
await mkdir(assetDir, { recursive: true })
const buffer = Buffer.from(await response.arrayBuffer())
await writeFile(resolvedFilePath, buffer)
return localAssetUrl(taskId, resolvedFileName)
}
export async function cacheTaskAssets(task: StoredTask): Promise<StoredTask> {
const output = task.output
if (!output?.results?.length) return task
let changed = false
const results: NonNullable<NonNullable<StoredTask['output']>['results']> = []
for (const result of output.results) {
const nextResult = { ...result }
for (const spec of assetSpecs) {
const remoteUrl = result[spec.remoteKey]
if (!remoteUrl) continue
if (result[spec.localKey]?.startsWith('/assets/')) continue
try {
const localUrl = await cacheRemoteAsset(task.taskId, remoteUrl, spec.baseName, spec.fallbackExtension)
if (localUrl && nextResult[spec.localKey] !== localUrl) {
nextResult[spec.localKey] = localUrl
changed = true
}
} catch (error) {
const message = error instanceof Error ? error.message : 'Unknown asset download error'
console.warn(`Could not cache ${spec.remoteKey} for task ${task.taskId}: ${message}`)
}
}
results.push(nextResult)
}
if (!changed) return task
return {
...task,
output: {
...output,
results,
},
updatedAt: new Date().toISOString(),
}
}
export async function cacheTasksAssets(tasks: StoredTask[]) {
const nextTasks: StoredTask[] = []
let changed = false
for (const task of tasks) {
const nextTask = await cacheTaskAssets(task)
nextTasks.push(nextTask)
if (nextTask !== task) changed = true
}
return { tasks: nextTasks, changed }
}