@dickpy/dsh-imagegen 1.5.0 → 1.5.2

package/src/templates-store.ts

@@ -1,12 +1,19 @@
 /**
- * Prompt-template library store (awesome-gpt-image-2 mirror).
+ * Prompt-template library store (multi-source).
  *
- * The case list ships as a bundled snapshot (src/templates/cases.json, inside
- * the npm package) so the library works offline out of the box; a successful
- * manual refresh writes a runtime copy under ~/.dsh/dsh-imagegen/templates/
- * which then takes precedence. Reference images are not bundled (441 files,
- * ≈100 MB) — they are fetched from the vibeui.top mirror on demand, cached on
- * disk under ~/.dsh/dsh-imagegen/template-images/, and served from there on
+ * The library is a registry of independent sources (see TEMPLATE_SOURCES in
+ * protocol.ts): each source has its own upstream JSON list, its own bundled
+ * snapshot, its own refreshed runtime copy, and its own on-disk image pool.
+ * Sources never mix — the overlay shows one tab per source and every request
+ * names the source explicitly.
+ *
+ * Each case list ships as a bundled snapshot (src/templates/<file>, inside the
+ * npm package) so every library works offline out of the box; a successful
+ * refresh (manual, or the periodic background sync) writes a runtime copy
+ * under ~/.dsh/dsh-imagegen/templates/<sourceId>/ which then takes precedence.
+ * Reference images are not bundled (hundreds of files, ≈100 MB per source) —
+ * they are fetched from the source's mirror on demand, cached on disk under
+ * ~/.dsh/dsh-imagegen/template-images/<sourceId>/, and served from there on
  * every later view.
  *
  * Framework-free (node:fs only) so the route layer and tests can drive it
@@ -17,15 +24,42 @@ import { promises as fs } from 'node:fs'
 import { homedir } from 'node:os'
 import path from 'node:path'
 import { fileURLToPath } from 'node:url'
-import type { TemplateCase, TemplateListResult, TemplateRefreshResult } from './protocol.ts'
+import { DEFAULT_TEMPLATE_SOURCE_ID, TEMPLATE_SOURCES, type TemplateCase, type TemplateListResult, type TemplateRefreshResult, type TemplateSample } from './protocol.ts'
 
-/** Upstream mirror the library refreshes from (vibeui.top static mirror). */
-const SOURCE_URL = 'https://vibeui.top/extra/awesome-gpt-image-2/data/cases.json'
+/** Host-side fetch definition of one source (ids mirror TEMPLATE_SOURCES). */
+interface TemplateSourceDef {
+  /** Upstream JSON list refreshed from. */
+  listUrl: string
+  /** Remote image directory (file names come from the case list). */
+  imageBaseUrl: string
+  /** Bundled snapshot shipped inside the package. */
+  bundledPath: string
+  /**
+   * Pre-1.6 single-source layout: refreshed copies and images lived in
+   * unscoped paths. Read as a fallback so existing users keep their state
+   * until the next refresh rewrites it into the scoped location.
+   */
+  legacySnapshotPath?: string
+  legacyImageDir?: string
+}
 
-/** Remote image directory (file names come from the case list). */
-const IMAGE_BASE_URL = 'https://vibeui.top/extra/awesome-gpt-image-2/data/images/'
+/** Source registry (host half): where each TEMPLATE_SOURCES entry loads from. */
+const SOURCE_DEFS: Record<string, TemplateSourceDef> = {
+  vibeui: {
+    listUrl: 'https://vibeui.top/extra/awesome-gpt-image-2/data/cases.json',
+    imageBaseUrl: 'https://vibeui.top/extra/awesome-gpt-image-2/data/images/',
+    bundledPath: fileURLToPath(new URL('../src/templates/cases.json', import.meta.url)),
+    legacySnapshotPath: 'legacy',
+    legacyImageDir: 'legacy',
+  },
+  canghe: {
+    listUrl: 'https://gpt-image2.canghe.ai/cases.json',
+    imageBaseUrl: 'https://gpt-image2.canghe.ai/images/',
+    bundledPath: fileURLToPath(new URL('../src/templates/canghe-cases.json', import.meta.url)),
+  },
+}
 
-/** Category label map mirrored from vibeui.top's site.js (zh display names). */
+/** Category label map mirrored from the upstream sites' site.js (zh names). */
 const CATEGORY_ZH: Record<string, string> = {
   'Architecture & Spaces': '建筑与空间',
   'Brand & Logos': '品牌与标志',
@@ -57,16 +91,11 @@ const CATEGORY_ZH: Record<string, string> = {
 }
 
 const DATA_DIR = path.join(homedir(), '.dsh', 'dsh-imagegen')
-const REFRESHED_CASES_PATH = path.join(DATA_DIR, 'templates', 'cases.json')
-const IMAGE_CACHE_DIR = path.join(DATA_DIR, 'template-images')
-
-/**
- * Bundled snapshot path. The host bundle emits to lib/index.js while this
- * source file lives at src/templates-store.ts — both exactly one level below
- * the package root — so `../src/templates/cases.json` resolves to the shipped
- * snapshot in development and in the installed package alike.
- */
-const BUNDLED_CASES_PATH = fileURLToPath(new URL('../src/templates/cases.json', import.meta.url))
+const REFRESHED_DIR = path.join(DATA_DIR, 'templates')
+const IMAGE_CACHE_ROOT = path.join(DATA_DIR, 'template-images')
+/** Pre-1.6 single-source locations (vibeui fallbacks). */
+const LEGACY_SNAPSHOT_PATH = path.join(REFRESHED_DIR, 'cases.json')
+const LEGACY_IMAGE_DIR = IMAGE_CACHE_ROOT
 
 /** Budget for one upstream fetch (list refresh or one image). */
 const FETCH_TIMEOUT_MS = 60_000
@@ -84,12 +113,17 @@ interface CasesSnapshot {
   cases?: unknown
 }
 
-/** In-memory memo of the active list (avoid re-parsing on every request). */
-let memo: TemplateListResult | undefined
+/** Per-source in-memory memo of the active list (avoid re-parsing per request). */
+const memos = new Map<string, TemplateListResult>()
 
 /** Per-file in-flight downloads, so a gallery scroll never double-fetches. */
 const inflightImages = new Map<string, Promise<{ data: Buffer; mime: string } | undefined>>()
 
+/** Resolve a registered source id to its fetch definition. */
+function sourceDefOf(sourceId: string): TemplateSourceDef | undefined {
+  return SOURCE_DEFS[sourceId]
+}
+
 /** Validate + normalize one raw upstream case; undefined when unusable. */
 function normalizeCase(raw: unknown): TemplateCase | undefined {
   if (raw === null || typeof raw !== 'object') return undefined
@@ -152,37 +186,46 @@ async function readSnapshotFile(file: string): Promise<ReturnType<typeof parseSn
 }
 
 /**
- * The active template list: the refreshed runtime copy wins, the bundled
- * snapshot is the always-available fallback. Memoized; a successful refresh
- * replaces the memo.
+ * The active template list of one source: the refreshed runtime copy wins, the
+ * bundled snapshot is the always-available fallback. Memoized per source; a
+ * successful refresh replaces that source's memo.
  */
-export async function listTemplates(): Promise<TemplateListResult> {
+export async function listTemplates(sourceId: string = DEFAULT_TEMPLATE_SOURCE_ID): Promise<TemplateListResult> {
+  const def = sourceDefOf(sourceId)
+  if (def === undefined) throw new Error(`未知的模板库来源：${sourceId}`)
+  const memo = memos.get(sourceId)
   if (memo !== undefined) return memo
-  const refreshed = await readSnapshotFile(REFRESHED_CASES_PATH)
+  const refreshed = await readSnapshotFile(path.join(REFRESHED_DIR, sourceId, 'cases.json'))
+    ?? (def.legacySnapshotPath !== undefined ? await readSnapshotFile(LEGACY_SNAPSHOT_PATH) : undefined)
   if (refreshed !== undefined) {
-    memo = { ...refreshed, total: refreshed.cases.length, origin: 'refreshed' }
-    return memo
+    const result: TemplateListResult = { sourceId, ...refreshed, total: refreshed.cases.length, origin: 'refreshed' }
+    memos.set(sourceId, result)
+    return result
   }
-  const bundled = await readSnapshotFile(BUNDLED_CASES_PATH)
+  const bundled = await readSnapshotFile(def.bundledPath)
   if (bundled !== undefined) {
-    memo = { ...bundled, total: bundled.cases.length, origin: 'bundled' }
-    return memo
+    const result: TemplateListResult = { sourceId, ...bundled, total: bundled.cases.length, origin: 'bundled' }
+    memos.set(sourceId, result)
+    return result
   }
-  memo = { cases: [], total: 0, origin: 'bundled', repository: 'freestylefly/awesome-gpt-image-2', fetchedAt: '' }
-  return memo
+  const result: TemplateListResult = { sourceId, cases: [], total: 0, origin: 'bundled', repository: 'freestylefly/awesome-gpt-image-2', fetchedAt: '' }
+  memos.set(sourceId, result)
+  return result
 }
 
 /**
- * Re-download the case list from the upstream mirror and persist it as the
- * runtime copy. Throws with a user-presentable message on failure; the
+ * Re-download one source's case list from its upstream mirror and persist it
+ * as the runtime copy. Throws with a user-presentable message on failure; the
  * previous list (refreshed or bundled) stays active.
  */
-export async function refreshTemplates(): Promise<TemplateRefreshResult> {
+export async function refreshTemplates(sourceId: string = DEFAULT_TEMPLATE_SOURCE_ID): Promise<TemplateRefreshResult> {
+  const def = sourceDefOf(sourceId)
+  if (def === undefined) throw new Error(`未知的模板库来源：${sourceId}`)
   let response: Response
   try {
-    response = await fetch(SOURCE_URL, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) })
+    response = await fetch(def.listUrl, { signal: AbortSignal.timeout(FETCH_TIMEOUT_MS) })
   } catch (error) {
-    throw new Error(`无法连接模板库源站：${error instanceof Error ? error.message : String(error)}`)
+    throw new Error(`无法连接模板库源站（${sourceId}）：${error instanceof Error ? error.message : String(error)}`)
   }
   if (!response.ok) throw new Error(`模板库源站拒绝请求（HTTP ${response.status}）`)
   let payload: unknown
@@ -196,17 +239,77 @@ export async function refreshTemplates(): Promise<TemplateRefreshResult> {
   const fetchedAt = new Date().toISOString()
   const snapshot = {
     repository: parsed.repository,
-    sourceUrl: SOURCE_URL,
+    sourceUrl: def.listUrl,
     fetchedAt,
     totalCases: parsed.cases.length,
     cases: parsed.cases,
   }
-  await fs.mkdir(path.dirname(REFRESHED_CASES_PATH), { recursive: true })
-  const tmp = `${REFRESHED_CASES_PATH}.tmp-${process.pid}`
+  const target = path.join(REFRESHED_DIR, sourceId, 'cases.json')
+  await fs.mkdir(path.dirname(target), { recursive: true })
+  const tmp = `${target}.tmp-${process.pid}`
   await fs.writeFile(tmp, JSON.stringify(snapshot), 'utf8')
-  await fs.rename(tmp, REFRESHED_CASES_PATH)
-  memo = { cases: parsed.cases, total: parsed.cases.length, origin: 'refreshed', repository: parsed.repository, fetchedAt }
-  return { total: parsed.cases.length, fetchedAt }
+  await fs.rename(tmp, target)
+  const result: TemplateListResult = { sourceId, cases: parsed.cases, total: parsed.cases.length, origin: 'refreshed', repository: parsed.repository, fetchedAt }
+  memos.set(sourceId, result)
+  return { sourceId, total: parsed.cases.length, fetchedAt }
+}
+
+/** Per-source outcome of one background sync pass. */
+export interface TemplateSyncReport {
+  sourceId: string
+  ok: boolean
+  total: number
+  error?: string
+}
+
+/** Fisher–Yates shuffle (returns a copy; never mutates the pool). */
+function shuffled<T>(items: T[]): T[] {
+  const out = [...items]
+  for (let i = out.length - 1; i > 0; i -= 1) {
+    const j = Math.floor(Math.random() * (i + 1))
+    const a = out[i]!
+    out[i] = out[j]!
+    out[j] = a
+  }
+  return out
+}
+
+/**
+ * Draw up to `count` random cases across every source that has data,
+ * round-robin between sources so one huge library cannot crowd out the
+ * others, then shuffle the final pick. Reads memoized lists, so this never
+ * touches the network — cheap enough for every shuffle click.
+ */
+export async function sampleTemplates(count: number = 9): Promise<TemplateSample[]> {
+  const size = Math.min(12, Math.max(1, Math.floor(count) || 9))
+  const pools: Array<{ sourceId: string; cases: TemplateCase[] }> = []
+  for (const source of TEMPLATE_SOURCES) {
+    try {
+      const list = await listTemplates(source.id)
+      if (list.cases.length > 0) pools.push({ sourceId: source.id, cases: shuffled(list.cases) })
+    } catch { /* an unusable source just contributes nothing */ }
+  }
+  const picks: TemplateSample[] = []
+  for (let round = 0; picks.length < size && pools.some(pool => pool.cases.length > 0); round += 1) {
+    const pool = pools[round % pools.length]!
+    const picked = pool.cases.pop()
+    if (picked !== undefined) picks.push({ sourceId: pool.sourceId, case: picked })
+  }
+  return shuffled(picks)
+}
+
+/** Serially refresh every registered source; one failure never stops the rest. */
+export async function syncAllTemplates(): Promise<TemplateSyncReport[]> {
+  const reports: TemplateSyncReport[] = []
+  for (const source of TEMPLATE_SOURCES) {
+    try {
+      const result = await refreshTemplates(source.id)
+      reports.push({ sourceId: source.id, ok: true, total: result.total })
+    } catch (error) {
+      reports.push({ sourceId: source.id, ok: false, total: 0, error: error instanceof Error ? error.message : String(error) })
+    }
+  }
+  return reports
 }
 
 /** MIME type for a cached reference-image file name. */
@@ -220,11 +323,11 @@ function mimeOfFile(file: string): string {
   }
 }
 
-/** Download one reference image into the disk cache; undefined on failure. */
-async function fetchTemplateImage(file: string): Promise<{ data: Buffer; mime: string } | undefined> {
+/** Download one reference image into the source's disk cache; undefined on failure. */
+async function fetchTemplateImage(def: TemplateSourceDef, file: string, cacheDir: string): Promise<{ data: Buffer; mime: string } | undefined> {
   let response: Response
   try {
-    response = await fetch(`${IMAGE_BASE_URL}${encodeURIComponent(file)}`, {
+    response = await fetch(`${def.imageBaseUrl}${encodeURIComponent(file)}`, {
       signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
     })
   } catch {
@@ -237,10 +340,10 @@ async function fetchTemplateImage(file: string): Promise<{ data: Buffer; mime: s
   if (data.byteLength === 0 || data.byteLength > MAX_IMAGE_BYTES) return undefined
   const mime = mimeOfFile(file)
   try {
-    await fs.mkdir(IMAGE_CACHE_DIR, { recursive: true })
-    const tmp = path.join(IMAGE_CACHE_DIR, `${file}.tmp-${process.pid}`)
+    await fs.mkdir(cacheDir, { recursive: true })
+    const tmp = path.join(cacheDir, `${file}.tmp-${process.pid}`)
     await fs.writeFile(tmp, data)
-    await fs.rename(tmp, path.join(IMAGE_CACHE_DIR, file))
+    await fs.rename(tmp, path.join(cacheDir, file))
   } catch {
     // A cache-write failure must not lose the already-fetched bytes.
   }
@@ -248,31 +351,39 @@ async function fetchTemplateImage(file: string): Promise<{ data: Buffer; mime: s
 }
 
 /**
- * Read one reference image for the template library. Cache hit → disk; miss →
- * fetch from the upstream mirror, cache, and serve. Only file names present in
- * the active case list are served, so the route can never act as an open
+ * Read one reference image for a source's library. Cache hit → disk; miss →
+ * fetch from that source's mirror, cache, and serve. Only file names present
+ * in the active case list are served, so the route can never act as an open
  * proxy. Undefined when the name is unknown or the fetch failed.
  */
-export async function readTemplateImage(file: string): Promise<{ data: Buffer; mime: string } | undefined> {
+export async function readTemplateImage(sourceId: string, file: string): Promise<{ data: Buffer; mime: string } | undefined> {
+  const def = sourceDefOf(sourceId)
+  if (def === undefined) return undefined
   if (!IMAGE_FILE_PATTERN.test(file) || file.includes('..')) return undefined
-  const list = await listTemplates()
+  const list = await listTemplates(sourceId)
   if (!list.cases.some(entry => entry.image === file)) return undefined
-  const cached = path.join(IMAGE_CACHE_DIR, file)
+  const cacheDir = path.join(IMAGE_CACHE_ROOT, sourceId)
   try {
-    return { data: await fs.readFile(cached), mime: mimeOfFile(file) }
-  } catch { /* fall through to download */ }
-  const inflight = inflightImages.get(file)
+    return { data: await fs.readFile(path.join(cacheDir, file)), mime: mimeOfFile(file) }
+  } catch { /* fall through to legacy cache / download */ }
+  if (def.legacyImageDir !== undefined) {
+    try {
+      return { data: await fs.readFile(path.join(LEGACY_IMAGE_DIR, file)), mime: mimeOfFile(file) }
+    } catch { /* fall through to download */ }
+  }
+  const cacheKey = `${sourceId}/${file}`
+  const inflight = inflightImages.get(cacheKey)
   if (inflight !== undefined) return inflight
-  const pending = fetchTemplateImage(file)
-  inflightImages.set(file, pending)
+  const pending = fetchTemplateImage(def, file, cacheDir)
+  inflightImages.set(cacheKey, pending)
   try {
     return await pending
   } finally {
-    inflightImages.delete(file)
+    inflightImages.delete(cacheKey)
   }
 }
 
-/** Drop the in-memory list memo (tests). */
+/** Drop the in-memory list memos (tests). */
 export function clearTemplateMemo(): void {
-  memo = undefined
+  memos.clear()
 }