feat: add asset import services

src/lib/services/pet-import.ts

@@ -0,0 +1,103 @@
+import { existsSync, promises as fs } from 'node:fs'
+import path from 'node:path'
+import { downloadFile } from '@/lib/services/import/core/download'
+import { CANONICAL_PETS, resolvePetSwfUrl } from '@/lib/services/pet-source'
+import { convertSwfToNitro } from '@/lib/services/swf-to-nitro'
+
+export interface PetListItem {
+  lib: string
+  nitroExists: boolean
+}
+
+export interface ImportPetResult {
+  ok: boolean
+  lib: string
+  warnings: string[]
+  error?: string
+}
+
+export const PET_NITRO_DIR = path.join(
+  /*turbopackIgnore: true*/ process.cwd(),
+  'public/nitro-assets/bundled/pet',
+)
+export const PET_SWF_DIR = path.join(/*turbopackIgnore: true*/ process.cwd(), 'public/swf/gordon')
+
+export async function ensurePetDirs(): Promise<void> {
+  await Promise.all(
+    [PET_NITRO_DIR, PET_SWF_DIR]
+      .filter((dir) => !existsSync(/*turbopackIgnore: true*/ dir))
+      .map((dir) => fs.mkdir(/*turbopackIgnore: true*/ dir, { recursive: true })),
+  )
+}
+
+function nitroPathFor(lib: string): string {
+  return path.join(/*turbopackIgnore: true*/ PET_NITRO_DIR, `${lib}.nitro`)
+}
+
+export async function importSinglePet(params: {
+  lib: string
+  onProgress?: (status: string) => void
+}): Promise<ImportPetResult> {
+  const { lib, onProgress } = params
+  const warnings: string[] = []
+  await ensurePetDirs()
+
+  onProgress?.('downloading')
+  const swfPath = path.join(/*turbopackIgnore: true*/ PET_SWF_DIR, `${lib}.swf`)
+  let swfUrl: string
+  try {
+    swfUrl = await resolvePetSwfUrl(lib)
+  } catch (err) {
+    return {
+      ok: false,
+      lib,
+      warnings,
+      error: `Could not resolve SWF URL: ${(err as Error).message}`,
+    }
+  }
+  const dl = await downloadFile(swfUrl, swfPath, { validate: 'swf' })
+  if (!dl.ok) return { ok: false, lib, warnings, error: `SWF download failed: ${swfUrl}` }
+
+  onProgress?.('converting')
+  try {
+    const swfBuffer = await fs.readFile(/*turbopackIgnore: true*/ swfPath)
+    const result = convertSwfToNitro(swfBuffer, lib)
+    await fs.writeFile(/*turbopackIgnore: true*/ nitroPathFor(lib), result.bundle)
+    if (result.warnings?.length) warnings.push(...result.warnings)
+  } catch (err) {
+    return {
+      ok: false,
+      lib,
+      warnings,
+      error: `SWF→Nitro conversion failed: ${(err as Error).message}`,
+    }
+  }
+
+  return { ok: true, lib, warnings }
+}
+
+export async function deleteImportedPet(lib: string): Promise<{ deletedFile: boolean }> {
+  const p = nitroPathFor(lib)
+  if (existsSync(/*turbopackIgnore: true*/ p)) {
+    await fs.unlink(/*turbopackIgnore: true*/ p).catch(() => {})
+    return { deletedFile: true }
+  }
+  return { deletedFile: false }
+}
+
+export function getPetList(search: string): PetListItem[] {
+  const term = search.trim().toLowerCase()
+  const list = CANONICAL_PETS.map((lib) => ({
+    lib,
+    nitroExists: existsSync(/*turbopackIgnore: true*/ nitroPathFor(lib)),
+  }))
+  return term ? list.filter((p) => p.lib.toLowerCase().includes(term)) : list
+}
+
+export function getPetStats(): { total: number; imported: number; missing: number } {
+  const imported = CANONICAL_PETS.filter((lib) =>
+    existsSync(/*turbopackIgnore: true*/ nitroPathFor(lib)),
+  ).length
+  return { total: CANONICAL_PETS.length, imported, missing: CANONICAL_PETS.length - imported }
+}
+