+ Your personal library at a glance +
.
- The browser resolves this to /read/{book_id}/images/pic.jpg.
- """
- # Security check: ensure book_id is clean
- safe_book_id = os.path.basename(book_id)
- safe_image_name = os.path.basename(image_name)
-
- img_path = os.path.join(BOOKS_DIR, safe_book_id, "images", safe_image_name)
-
- if not os.path.exists(img_path):
+async def serve_book_image(book_id: str, image_name: str):
+ """Serve an image file from a book's extracted images directory."""
+ safe_name = os.path.basename(image_name)
+ image_path = os.path.join(BOOKS_DIR, book_id, "images", safe_name)
+ if not os.path.exists(image_path):
raise HTTPException(status_code=404, detail="Image not found")
+ return FileResponse(image_path)
+
+
+# --- Rename book ---
+@app.post("/api/rename-book/{book_id}")
+async def rename_book(book_id: str, request: Request):
+ """Set display_title for a book. Empty string removes custom title."""
+ req = await request.json()
+ title = req.get("title", "").strip()
+ index = {}
+ if os.path.exists(_LIBRARY_INDEX):
+ with open(_LIBRARY_INDEX, 'r') as f:
+ index = json.load(f)
+ if book_id not in index:
+ raise HTTPException(status_code=404, detail="Book not found")
+ if title:
+ index[book_id]['display_title'] = title
+ else:
+ index[book_id].pop('display_title', None)
+ with open(_LIBRARY_INDEX, 'w') as f:
+ json.dump(index, f, ensure_ascii=False)
+ return {"ok": True, "display_title": title or None}
+
+
+# --- Delete books ---
+@app.post("/api/delete-books")
+async def delete_books(req: dict):
+ """Delete one or more books by their IDs."""
+ import shutil
+ book_ids = req.get("book_ids", [])
+ if not book_ids:
+ raise HTTPException(status_code=400, detail="No books specified")
+ deleted = []
+ for bid in book_ids:
+ safe_id = os.path.basename(bid)
+ book_dir = os.path.join(BOOKS_DIR, safe_id)
+ if os.path.isdir(book_dir) and os.path.exists(os.path.join(book_dir, "book.pkl")):
+ await asyncio.to_thread(shutil.rmtree, book_dir)
+ deleted.append(safe_id)
+ load_book_cached.cache_clear()
+ return {"deleted": deleted, "count": len(deleted)}
+
+# --- AI MODULE REFACTORED (Gemini 3 Pro standards) ---
+
+class AIAnalyzeRequest(BaseModel):
+ book_id: str
+ chapter_index: int
+
+@app.post("/api/ai/analyze")
+async def analyze_chapter(req: AIAnalyzeRequest):
+ """Analyze a chapter and return structured insights."""
+ book = load_book_cached(req.book_id)
+ if not book or req.chapter_index < 0 or req.chapter_index >= len(book.spine):
+ raise HTTPException(status_code=404, detail="Chapter not found")
+ chapter = book.spine[req.chapter_index]
+
+ # Use text field, fallback to stripping HTML from content
+ chapter_text = chapter.text.strip()
+ if not chapter_text and chapter.content:
+ from html.parser import HTMLParser
+ class _Strip(HTMLParser):
+ def __init__(self):
+ super().__init__()
+ self.parts = []
+ def handle_data(self, d):
+ self.parts.append(d)
+ s = _Strip()
+ s.feed(chapter.content)
+ chapter_text = ' '.join(s.parts).strip()
+
+ if len(chapter_text) < 20:
+ return {
+ "summary": "本章内容过短，无法进行有效分析。",
+ "key_points": [],
+ "difficulties": "",
+ "insight": ""
+ }
+
+ # server-cache-lru: Fingerprint based on text content hash
+ content_hash = _get_text_hash(chapter_text)
+ cache_key = f"{req.book_id}:{req.chapter_index}:{content_hash}"
+
+ if cache_key in _analysis_cache:
+ return _analysis_cache[cache_key]
+
+ prompt = f"""你是一位经验丰富的读书会领读者，同时具备深厚的文学素养和跨学科知识。
+你正在带领一群认真的成年读者讨论这本书。你的风格：有见地但不卖弄，善于发现文字背后的深意。
+
+书名：{book.metadata.title}
+作者：{', '.join(book.metadata.authors) if book.metadata.authors else '未知'}
+章节：{chapter.title}
+
+【本章内容】：
+{chapter_text[:15000]}
+
+请阅读后，以领读者的身份进行分析。严格按以下 JSON 返回（不要包含 ```json 标记）：
+
+{{
+ "summary": "用 150-250 字概述本章核心内容。不要罗列事件，而是说清楚：这一章到底在讲什么、推进了什么、改变了什么。如果是非虚构类，提炼核心论点和关键论据。",
+ "key_points": [
+ "提炼 3-5 个本章最值得关注的要点。每个要点用一句话点明是什么，再用一句话说明为什么重要。不要泛泛而谈。"
+ ],
+ "difficulties": "找出本章中读者可能卡住的地方：专业术语、文化背景、隐晦的表达、复杂的逻辑链等，用大白话解释清楚。如果没有难点就坦诚说明。",
+ "insight": "分享一个有启发性的深层解读：可以是与其他作品的对比、一个反直觉的发现、当下社会的映射、或者作者没有明说但暗含的立场。要言之有物，避免空洞的感悟。"
+}}"""
+
+ try:
+ text, used_model = await _ai_complete(prompt, temperature=0.3, max_tokens=8192, task='analyze')
+
+ # Robust JSON cleaning
+ if "{" in text and "}" in text:
+ text = text[text.find("{"):text.rfind("}")+1]
+
+ result = json.loads(text)
+ result["_model"] = used_model
+ _analysis_cache[cache_key] = result # Cache the processed object
+ return result
+ except json.JSONDecodeError as e:
+ raise HTTPException(status_code=500, detail=f"Analysis failed: invalid JSON from AI")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Analysis failed: {str(e)}")
+
+@app.post("/api/ai/translate")
+async def translate_text(req: dict):
+ """Translate text using unified AI dispatch."""
+ text = req.get("text", "")
+ if not text:
+ return {"translation": ""}
+
+ # Auto-detect: if mostly CJK → translate to English, otherwise → translate to Chinese
+ cjk_count = sum(1 for c in text if '\u4e00' <= c <= '\u9fff' or '\u3040' <= c <= '\u30ff' or '\uac00' <= c <= '\ud7af')
+ target = "英文" if cjk_count > len(text) * 0.3 else "中文"
+
+ prompt = f"""请将以下文本翻译成{target}。
+
+翻译要求：
+- 准确传达原意，语句通顺自然，符合{target}的表达习惯
+- 专有名词（人名、地名、术语）首次出现时附注原文
+- 保留原文的语气和风格（正式/口语/文学/技术）
+- 只返回译文，不要解释
+
+原文：
+{text}"""
+
+ try:
+ result, _ = await _ai_complete(prompt, temperature=0.1, max_tokens=4096, task='translate')
+ return {"translation": result.strip()}
+ except Exception as e:
+ return {"translation": f"[Translation Error: {str(e)}]"}
+
+
+@app.post("/api/ai/translate-stream")
+async def translate_text_stream(req: dict):
+ """Translate text with streaming output using unified AI dispatch."""
+ text = req.get("text", "")
+ if not text:
+ return StreamingResponse(iter([""]), media_type="text/plain")
+
+ # Auto-detect: if mostly CJK → translate to English, otherwise → translate to Chinese
+ cjk_count = sum(1 for c in text if '\u4e00' <= c <= '\u9fff' or '\u3040' <= c <= '\u30ff' or '\uac00' <= c <= '\ud7af')
+ target = "英文" if cjk_count > len(text) * 0.3 else "中文"
+
+ # Build context from book metadata
+ context = ""
+ book_id = req.get("book_id")
+ chapter_index = req.get("chapter_index")
+ if book_id:
+ book = load_book_cached(book_id)
+ if book:
+ meta = book.metadata
+ parts = [f"书名《{meta.title}》"]
+ if meta.authors:
+ parts.append(f"作者{', '.join(meta.authors)}")
+ if chapter_index is not None and 0 <= chapter_index < len(book.spine):
+ ch_title = book.spine[chapter_index].title
+ if ch_title:
+ parts.append(f"当前章节「{ch_title}」")
+ context = f"[{', '.join(parts)}] "
+
+ prompt = f"{context}将以下内容完整翻译成{target}，所有词汇都必须翻译，不得保留原文（专有名词首次出现时括号附注原文除外），只返回译文：\n{text}"
+
+ gen = await _ai_stream(prompt, temperature=0.1, max_tokens=4096, task='translate')
+ return StreamingResponse(gen, media_type="text/plain; charset=utf-8")
+
+
+@app.post("/api/quick-translate")
+async def quick_translate(req: dict):
+ """Dict lookup (instant) → Google Translate fallback (~100ms). Chinese words get AI definitions."""
+ text = (req.get("text") or "").strip()
+ if not text:
+ return {"translation": ""}
+
+ # Step 1: Try local dictionary for single words/short phrases
+ dict_result = _dict_lookup(text)
+ if dict_result:
+ return {
+ "source": "dict",
+ "word": dict_result['word'],
+ "phonetic": dict_result['phonetic'],
+ "translation": dict_result['translation'],
+ "definition": dict_result['definition'],
+ }
+
+ # Step 2: Chinese text → local Chinese dictionary (457K entries, <1ms)
+ is_cjk = _detect_cjk_ratio(text) > 0.3
+ if is_cjk:
+ cn_result = _cn_dict_lookup(text)
+ if cn_result:
+ return {
+ "source": "cn-dict",
+ "word": cn_result['word'],
+ "pinyin": cn_result['pinyin'],
+ "translation": cn_result['definition'],
+ }
+
+ # Step 3: Chinese text → AI definition (fallback for words not in local dict)
+ if is_cjk and len(text) <= 20:
+ defn = await _chinese_define(text)
+ if defn:
+ return {"source": "ai-dict", "word": text, "translation": defn}
+
+ # Step 4: Fallback to Google Translate
+ dest = 'en' if is_cjk else 'zh-CN'
+ try:
+ translation = await _google_translate(text, dest)
+ return {"source": "google", "translation": translation}
+ except Exception as e:
+ return {"source": "error", "translation": "", "error": str(e)}
+
+
+@app.post("/api/wiki-lookup")
+async def wiki_lookup(req: dict):
+ """Wikipedia summary for a term."""
+ text = (req.get("text") or "").strip()
+ if not text:
+ return {"extract": ""}
+ result = await _wiki_summary(text)
+ return result
+
+
+@app.post("/api/search")
+async def search_book(req: dict):
+ """Full-text search across all chapters of a book."""
+ book_id = (req.get("book_id") or "").strip()
+ query = (req.get("query") or "").strip()
+ if not book_id or not query:
+ return {"results": []}
+ book = load_book_cached(book_id)
+ if not book:
+ return {"results": []}
+ lower_q = query.lower()
+ results = []
+ for ch in book.spine:
+ text = ch.text or ""
+ lower_text = text.lower()
+ pos = 0
+ while (pos := lower_text.find(lower_q, pos)) != -1:
+ start = max(0, pos - 40)
+ end = min(len(text), pos + len(query) + 40)
+ snippet = ("..." if start > 0 else "") + text[start:end] + ("..." if end < len(text) else "")
+ results.append({
+ "chapterIndex": ch.order,
+ "chapterTitle": ch.title,
+ "snippet": snippet,
+ "matchStart": pos,
+ })
+ pos += len(query)
+ if len(results) >= 200:
+ break
+ if len(results) >= 200:
+ break
+ return {"results": results}
+
+
+class AIChatRequest(BaseModel):
+ book_id: str
+ chapter_index: int
+ question: str
+
+
+@app.post("/api/ai/chat")
+async def chat_about_chapter(req: AIChatRequest):
+ """Answer a free-form question about the current chapter."""
+ book = load_book_cached(req.book_id)
+ if not book or req.chapter_index < 0 or req.chapter_index >= len(book.spine):
+ raise HTTPException(status_code=404, detail="Chapter not found")
+ chapter = book.spine[req.chapter_index]
+
+ # Use text field, fallback to stripping HTML from content
+ chapter_text = chapter.text.strip()
+ if not chapter_text and chapter.content:
+ from html.parser import HTMLParser
+ class _Strip(HTMLParser):
+ def __init__(self):
+ super().__init__()
+ self.parts = []
+ def handle_data(self, d):
+ self.parts.append(d)
+ s = _Strip()
+ s.feed(chapter.content)
+ chapter_text = ' '.join(s.parts).strip()
+
+ prompt = f"""你是这本书的深度阅读伙伴。基于章节内容回答问题时：
+- 尽量引用原文中的具体段落或细节来支撑回答
+- 如果问题涉及更广的背景知识，可以拓展，但要标注哪些是原文内容、哪些是补充
+- 用与提问者相同的语言回答
+- 回答要有条理，必要时使用小标题分段
+
+书名：{book.metadata.title}
+作者：{', '.join(book.metadata.authors) if book.metadata.authors else '未知'}
+章节：{chapter.title}
+
+【章节内容】：
+{chapter_text[:12000]}
+
+【读者提问】：
+{req.question}"""
+
+ try:
+ gen = await _ai_stream(prompt, temperature=0.7, max_tokens=4096, task='chat')
+ return StreamingResponse(gen, media_type="text/plain; charset=utf-8")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Chat failed: {str(e)}")
+
+
+@app.post("/api/ai/chat-context")
+async def chat_with_context(req: dict):
+ """AI chat with arbitrary text context (for PDF reader etc.)."""
+ question = (req.get("question") or "").strip()
+ context = (req.get("context") or "").strip()
+ title = (req.get("title") or "").strip()
+ if not question:
+ raise HTTPException(status_code=400, detail="No question provided")
+
+ parts = []
+ if title:
+ parts.append(f"当前阅读：《{title}》")
+ if context:
+ parts.append(f"【选中文本】：\n{context[:6000]}")
+ parts.append(f"【提问】：{question}")
+
+ prompt = "你是一位知识渊博的阅读助手。用与提问者相同的语言回答。回答要有条理。" \
+ "如果提供了选中文本，请结合该文本来回答。\n\n" + "\n\n".join(parts)
+
+ try:
+ gen = await _ai_stream(prompt, temperature=0.7, max_tokens=4096, task='chat')
+ return StreamingResponse(gen, media_type="text/plain; charset=utf-8")
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Chat failed: {str(e)}")
+
+
+# --- AI Provider Management API ---
+
+@app.get("/api/ai/providers")
+async def get_providers():
+ """Return provider list with status (key masked)."""
+ _load_ai_config()
+ result = []
+ seen = set()
+ def _entry(pid, p):
+ defn = _PROVIDER_DEFS.get(pid, {})
+ if not defn and pid.startswith('custom'):
+ defn = _PROVIDER_DEFS.get('custom', {})
+ key = p.get('api_key', '')
+ name = p.get('custom_name') or defn.get('name', pid)
+ entry = {
+ 'id': pid, 'name': name,
+ 'has_key': bool(key), 'key_preview': key[:3] + '******' + key[-3:] if len(key) > 6 else ('******' if key else ''),
+ 'enabled': p.get('enabled', False),
+ 'model': p.get('model') or defn.get('default_model', ''),
+ 'base_url': p.get('base_url', ''),
+ 'default_model': defn.get('default_model', ''),
+ 'default_base_url': defn.get('base_url', ''),
+ }
+ if p.get('temperature') is not None:
+ entry['temperature'] = p['temperature']
+ if p.get('max_tokens') is not None:
+ entry['max_tokens'] = p['max_tokens']
+ if pid.startswith('custom'):
+ entry['custom_name'] = p.get('custom_name', '')
+ return entry
+ # Build map of builtin keys for filtering migrated entries
+ builtin_keys = {pid: bkey for pid, bkey, _ in _get_builtin_providers()}
+ for pid in _ai_config.get('order', []):
+ if pid in _ai_config.get('providers', {}):
+ p = _ai_config['providers'][pid]
+ # Skip entries whose key matches a builtin .env key (legacy migration artifacts)
+ if pid in builtin_keys and p.get('api_key') == builtin_keys[pid]:
+ continue
+ seen.add(pid)
+ result.append(_entry(pid, p))
+ for pid, p in _ai_config.get('providers', {}).items():
+ if pid not in seen:
+ if pid in builtin_keys and p.get('api_key') == builtin_keys[pid]:
+ continue
+ result.append(_entry(pid, p))
+ return {"providers": result, "available": list(_PROVIDER_DEFS.keys()), "task_routing": _ai_config.get('task_routing', {})}
+
+
+@app.post("/api/ai/providers")
+async def save_providers(req: dict):
+ """Save provider configuration. Empty api_key = keep existing key."""
+ providers = req.get('providers', [])
+ old_providers = _ai_config.get('providers', {})
+ _ai_config['providers'] = {}
+ _ai_config['order'] = []
+ for p in providers:
+ pid = p.get('id', '')
+ if not pid:
+ continue
+ _ai_config['order'].append(pid)
+ new_key = p.get('api_key', '')
+ # If no new key provided, keep the old one
+ if not new_key and pid in old_providers:
+ new_key = old_providers[pid].get('api_key', '')
+ _ai_config['providers'][pid] = {
+ 'api_key': new_key,
+ 'enabled': p.get('enabled', False),
+ 'model': p.get('model', ''),
+ 'base_url': p.get('base_url', ''),
+ }
+ if pid.startswith('custom') and p.get('custom_name'):
+ _ai_config['providers'][pid]['custom_name'] = p['custom_name']
+ if p.get('temperature') is not None:
+ _ai_config['providers'][pid]['temperature'] = p['temperature']
+ if p.get('max_tokens') is not None:
+ _ai_config['providers'][pid]['max_tokens'] = p['max_tokens']
+ # Save task routing if provided
+ if 'task_routing' in req:
+ _ai_config['task_routing'] = req['task_routing']
+ _save_ai_config()
+ _load_ai_config()
+ return {"ok": True}
+
+
+@app.post("/api/ai/test-provider")
+async def test_provider(req: dict):
+ """Test a provider's API key by making a minimal request."""
+ pid = req.get('id', '')
+ api_key = req.get('api_key', '')
+ model_name = req.get('model', '')
+ base_url = req.get('base_url', '')
+ defn = _PROVIDER_DEFS.get(pid, {})
+ if not defn and pid.startswith('custom'):
+ defn = _PROVIDER_DEFS.get('custom', {})
+ fmt = defn.get('format', 'openai')
+ # Fallback to stored key if not provided
+ if not api_key and pid in _ai_config.get('providers', {}):
+ api_key = _ai_config['providers'][pid].get('api_key', '')
+ if not api_key:
+ return {"ok": False, "message": "No API key provided"}
+ if not model_name:
+ model_name = defn.get('default_model', '')
+
+ if fmt == 'gemini':
+ try:
+ client = google_genai.Client(api_key=api_key)
+ resp = await asyncio.to_thread(lambda: client.models.generate_content(model=model_name, contents="Say 'ok'"))
+ return {"ok": True, "message": f"Connected: {model_name}"}
+ except Exception as e:
+ return {"ok": False, "message": str(e)}
+
+ if not base_url:
+ base_url = defn.get('base_url', '')
+ if not base_url:
+ return {"ok": False, "message": "No base URL configured"}
+ def _extract_error(resp):
+ """Extract human-readable error from API response."""
+ try:
+ body = resp.json()
+ # OpenAI / DashScope / most providers: {"error": {"message": "..."}}
+ err = body.get('error') or body.get('errors') or {}
+ if isinstance(err, dict):
+ msg = err.get('message', '')
+ code = err.get('code', '')
+ return f"{code}: {msg}" if code else msg
+ if isinstance(err, str):
+ return err
+ return str(body)[:200]
+ except Exception:
+ return resp.text[:200] if hasattr(resp, 'text') else f"HTTP {resp.status_code}"
+
+ try:
+ if fmt == 'anthropic':
+ async with httpx.AsyncClient(timeout=15, trust_env=True, headers={"User-Agent": "Reader3/1.0"}) as client:
+ resp = await client.post(
+ f"{base_url.rstrip('/')}/messages",
+ headers={"x-api-key": api_key, "anthropic-version": "2023-06-01", "Content-Type": "application/json"},
+ json={"model": model_name, "max_tokens": 10, "messages": [{"role": "user", "content": "Say ok"}]},
+ )
+ if resp.status_code != 200:
+ return {"ok": False, "message": _extract_error(resp)}
+ return {"ok": True, "message": f"Connected: {model_name}"}
+ else:
+ headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+ body = {"model": model_name, "messages": [{"role": "user", "content": "Say ok"}], "max_tokens": 10}
+ if pid == 'zhipuai':
+ body["thinking"] = {"type": "disabled"}
+ async with httpx.AsyncClient(timeout=15, trust_env=True, headers={"User-Agent": "Reader3/1.0"}) as client:
+ resp = await client.post(f"{base_url.rstrip('/')}/chat/completions", headers=headers, json=body)
+ if resp.status_code != 200:
+ return {"ok": False, "message": _extract_error(resp)}
+ return {"ok": True, "message": f"Connected: {model_name}"}
+ except Exception as e:
+ return {"ok": False, "message": str(e)}
+
+
+@app.get("/api/ai/export-config")
+async def export_config():
+ """Export AI provider config as downloadable JSON file."""
+ _load_ai_config()
+ from fastapi.responses import Response
+ content = json.dumps(_ai_config, indent=2, ensure_ascii=False)
+ return Response(content=content, media_type="application/json",
+ headers={"Content-Disposition": "attachment; filename=ai_config.json"})
+
+
+@app.post("/api/ai/import-config")
+async def import_config(req: dict):
+ """Import AI provider config from uploaded JSON."""
+ if 'providers' not in req or not isinstance(req['providers'], dict):
+ raise HTTPException(status_code=400, detail="Invalid config: missing 'providers' object")
+ global _ai_config
+ _ai_config = req
+ _ai_config.setdefault('order', list(req['providers'].keys()))
+ _ai_config.setdefault('task_routing', {})
+ _save_ai_config()
+ _load_ai_config()
+ return {"ok": True, "count": len(_ai_config['providers'])}
+
+
+@app.post("/api/ai/fetch-models")
+async def fetch_models(req: dict):
+ """Fetch available models from a provider."""
+ pid = req.get('id', '')
+ api_key = req.get('api_key', '')
+ base_url = req.get('base_url', '')
+ defn = _PROVIDER_DEFS.get(pid, {})
+ if not defn and pid.startswith('custom'):
+ defn = _PROVIDER_DEFS.get('custom', {})
+ fmt = defn.get('format', 'openai')
+ # Fallback to stored key if not provided
+ if not api_key and pid in _ai_config.get('providers', {}):
+ api_key = _ai_config['providers'][pid].get('api_key', '')
+ if not api_key:
+ return {"models": [], "error": "No API key provided"}
+
+ try:
+ if fmt == 'gemini':
+ client = google_genai.Client(api_key=api_key)
+ models = await asyncio.to_thread(lambda: [m.name.replace('models/', '') for m in client.models.list() if 'generateContent' in (m.supported_actions or [])])
+ return {"models": models}
+ except Exception as e:
+ return {"models": [], "error": str(e)}
+
+ if not base_url:
+ base_url = defn.get('base_url', '')
+ if not base_url:
+ return {"models": [], "error": "No base URL configured"}
+
+ try:
+ if fmt == 'anthropic':
+ async with httpx.AsyncClient(timeout=15, trust_env=True, headers={"User-Agent": "Reader3/1.0"}) as client:
+ resp = await client.get(f"{base_url.rstrip('/')}/models", headers={"x-api-key": api_key, "anthropic-version": "2023-06-01"})
+ resp.raise_for_status()
+ data = resp.json()
+ models = [m['id'] for m in data.get('data', [])]
+ return {"models": models}
+ else:
+ async with httpx.AsyncClient(timeout=15, trust_env=True, headers={"User-Agent": "Reader3/1.0"}) as client:
+ resp = await client.get(f"{base_url.rstrip('/')}/models", headers={"Authorization": f"Bearer {api_key}"})
+ resp.raise_for_status()
+ data = resp.json()
+ # Handle both {"data": [...]} (OpenAI) and [...] (Together AI) formats
+ items = data.get('data', data) if isinstance(data, dict) else data
+ models = [m['id'] for m in items if isinstance(m, dict) and 'id' in m]
+ return {"models": sorted(models)}
+ except Exception as e:
+ return {"models": [], "error": str(e)}
+
+
+# --- Dictionary Management API ---
+
+@app.get("/api/dict/status")
+async def dict_status():
+ """Return dictionary install status and download URL availability."""
+ dict_url = _ai_config.get('dict_url', '').strip() or _DEFAULT_DICT_URL
+ items = {}
+ for did, info in _DICT_FILES.items():
+ path = os.path.join(_DICT_DIR, info['filename'])
+ exists = os.path.exists(path)
+ items[did] = {
+ 'label': info['label'], 'label_en': info['label_en'],
+ 'installed': exists,
+ 'size_mb': round(os.path.getsize(path) / 1048576) if exists else info['size_mb'],
+ 'gz_mb': info['gz_mb'],
+ }
+ return {'dicts': items, 'has_url': bool(dict_url)}
+
+
+_dict_downloading = set() # prevent concurrent downloads
+
+@app.post("/api/dict/download")
+async def download_dict(req: dict):
+ """Download and decompress a dictionary file. Streams SSE progress."""
+ dict_id = req.get('id', '')
+ info = _DICT_FILES.get(dict_id)
+ if not info:
+ raise HTTPException(status_code=400, detail="Unknown dictionary id")
+ if dict_id in _dict_downloading:
+ raise HTTPException(status_code=409, detail="Already downloading")
+ dict_url = _ai_config.get('dict_url', '').strip() or _DEFAULT_DICT_URL
+ gz_url = f"{dict_url.rstrip('/')}/{info['filename']}.gz"
+ dest = os.path.join(_DICT_DIR, info['filename'])
+ tmp = dest + '.tmp'
+ expected_gz = info['gz_mb'] * 1048576 # fallback total size
+
+ async def stream():
+ _dict_downloading.add(dict_id)
+ try:
+ import urllib.request
+ os.makedirs(_DICT_DIR, exist_ok=True)
+ decomp = zlib.decompressobj(16 + zlib.MAX_WBITS)
+
+ def _download():
+ req = urllib.request.Request(gz_url, headers={'User-Agent': 'Reader3/1.0'})
+ proxy_url = _ai_config.get('proxy', '').strip()
+ if proxy_url:
+ handler = urllib.request.ProxyHandler({
+ 'http': proxy_url, 'https': proxy_url,
+ })
+ opener = urllib.request.build_opener(handler)
+ else:
+ opener = urllib.request.build_opener() # respects env http_proxy
+ return opener.open(req, timeout=300)
+
+ resp = await asyncio.to_thread(_download)
+ total = int(resp.headers.get('Content-Length', 0)) or expected_gz
+ downloaded = 0
+ last_pct = -1
+ with open(tmp, 'wb') as f:
+ while True:
+ chunk = await asyncio.to_thread(resp.read, 65536)
+ if not chunk:
+ break
+ decompressed = decomp.decompress(chunk)
+ f.write(decompressed)
+ downloaded += len(chunk)
+ pct = min(int(downloaded * 100 / total), 99) if total else 0
+ if pct > last_pct:
+ last_pct = pct
+ yield f"data: {json.dumps({'progress': pct})}\n\n"
+ remaining = decomp.flush()
+ if remaining:
+ f.write(remaining)
+ if os.path.exists(tmp):
+ os.replace(tmp, dest)
+ _reload_dict()
+ yield f"data: {json.dumps({'done': True})}\n\n"
+ else:
+ yield f"data: {json.dumps({'error': 'Download failed: temp file missing'})}\n\n"
+ except Exception as e:
+ if os.path.exists(tmp):
+ os.unlink(tmp)
+ yield f"data: {json.dumps({'error': str(e)})}\n\n"
+ finally:
+ _dict_downloading.discard(dict_id)
+
+ return StreamingResponse(stream(), media_type='text/event-stream')
+
+
+# --- TTS MODULE: edge-tts (local, free, low latency) ---
+
+@app.get("/api/tts")
+async def stream_tts(text: str, voice: str = "zh-CN-XiaoxiaoNeural", rate: str = "+0%"):
+ """Stream TTS audio via edge-tts."""
+ communicate = edge_tts.Communicate(text, voice, rate=rate)
+ async def generate():
+ async for chunk in communicate.stream():
+ if chunk["type"] == "audio":
+ yield chunk["data"]
+ return StreamingResponse(generate(), media_type="audio/mpeg")
+
+# --- Apple Books Integration ---
+
+APPLE_BOOKS_DB = os.path.expanduser(
+ "~/Library/Containers/com.apple.iBooksX/Data/Documents/BKLibrary/BKLibrary-1-091020131601.sqlite"
+)
+APPLE_BOOKS_COVER_DIR = os.path.expanduser(
+ "~/Library/Containers/com.apple.iBooksX/Data/Library/Caches/BCCoverCache-1/BICDiskDataStore"
+)
+
+@app.get("/api/apple-books")
+async def list_apple_books():
+ """List books from Apple Books library."""
+ if not os.path.exists(APPLE_BOOKS_DB):
+ return {"books": [], "error": "Apple Books database not found"}
+
+ def _query():
+ conn = sqlite3.connect(APPLE_BOOKS_DB)
+ conn.row_factory = sqlite3.Row
+ rows = conn.execute(
+ "SELECT ZTITLE, ZAUTHOR, ZPATH, ZFILESIZE, ZASSETID FROM ZBKLIBRARYASSET "
+ "WHERE ZTITLE IS NOT NULL AND ZPATH IS NOT NULL AND ZCONTENTTYPE = 1 "
+ "ORDER BY ZTITLE"
+ ).fetchall()
+ conn.close()
+ return [dict(r) for r in rows]
+
+ rows = await asyncio.to_thread(_query)
+
+ # Build a set of imported book titles (extracted from directory names) for fuzzy matching
+ imported_titles = set()
+ if os.path.isdir(BOOKS_DIR):
+ for d in os.listdir(BOOKS_DIR):
+ if d.endswith("_data") and os.path.exists(os.path.join(BOOKS_DIR, d, "book.pkl")):
+ # "失衡的免疫 - 【法】蒙蒂·莱曼_data" → "失衡的免疫"
+ name = d[:-5] # strip "_data"
+ title_part = name.split(" - ")[0].strip()
+ imported_titles.add(title_part.lower())
+
+ def _normalize(s):
+ """Strip punctuation and whitespace for fuzzy title comparison."""
+ return _re.sub(r'[\s\W]+', '', s).lower()
+
+ imported_normalized = {_normalize(t): t for t in imported_titles}
+
+ def _is_imported(r):
+ # 1. Check by epub filename
+ base_name = os.path.splitext(os.path.basename(r['ZPATH']))[0]
+ if os.path.exists(os.path.join(BOOKS_DIR, base_name + "_data", "book.pkl")):
+ return True
+ # 2. Check by Apple Books title + author
+ title_name = _safe_dirname(r['ZTITLE'], [r['ZAUTHOR']] if r['ZAUTHOR'] else None)
+ if os.path.exists(os.path.join(BOOKS_DIR, title_name + "_data", "book.pkl")):
+ return True
+ # 3. Fuzzy: require full normalized equality (prefix match too loose for serials)
+ ab_norm = _normalize(r['ZTITLE'])
+ if ab_norm in imported_normalized:
+ return True
+ return False
+
+ books = []
+ for r in rows:
+ path = r['ZPATH']
+ if not path or not os.path.exists(path):
+ continue
+ books.append({
+ "title": r['ZTITLE'],
+ "author": r['ZAUTHOR'] or '',
+ "path": path,
+ "size_mb": round((r['ZFILESIZE'] or 0) / 1048576, 1),
+ "imported": _is_imported(r),
+ "asset_id": r['ZASSETID'] or '',
+ })
+ return {"books": books}
+
+
+@app.get("/api/apple-books/cover/{asset_id}")
+async def serve_apple_books_cover(asset_id: str):
+ """Serve a cover image from Apple Books cache."""
+ import subprocess
+ safe_id = os.path.basename(asset_id)
+ cover_dir = os.path.join(APPLE_BOOKS_COVER_DIR, safe_id)
+ if not os.path.isdir(cover_dir):
+ raise HTTPException(status_code=404, detail="Cover not found")
+ # Check for cached JPEG first
+ jpeg_path = os.path.join(cover_dir, f"{safe_id}.jpg")
+ if os.path.exists(jpeg_path) and os.path.getsize(jpeg_path) > 0:
+ return FileResponse(jpeg_path, media_type="image/jpeg")
+ # Find largest HEIC file (best quality)
+ import glob as _glob
+ heics = sorted(_glob.glob(os.path.join(cover_dir, "*.heic")), key=os.path.getsize, reverse=True)
+ if not heics:
+ raise HTTPException(status_code=404, detail="No cover image")
+ # Convert HEIC to JPEG synchronously (awaited)
+ result = await asyncio.to_thread(
+ subprocess.run,
+ ["sips", "-s", "format", "jpeg", heics[0], "--out", jpeg_path],
+ capture_output=True, timeout=10
+ )
+ if os.path.exists(jpeg_path) and os.path.getsize(jpeg_path) > 0:
+ return FileResponse(jpeg_path, media_type="image/jpeg")
+ raise HTTPException(status_code=500, detail="Cover conversion failed")
+
+
+@app.post("/api/import-local")
+async def import_local_epub(req: dict):
+ """Import an EPUB or PDF from a local file path (e.g. Apple Books)."""
+ path = req.get("path", "")
+ if not path or not os.path.exists(path):
+ raise HTTPException(status_code=400, detail="File not found")
+ path_lower = path.lower()
+ if not (path_lower.endswith('.epub') or path_lower.endswith('.pdf')):
+ raise HTTPException(status_code=400, detail="Only .epub and .pdf files are supported")
+
+ is_pdf = path_lower.endswith('.pdf')
+ base_name = os.path.splitext(os.path.basename(path))[0]
+ out_dir = os.path.join(BOOKS_DIR, base_name + "_data")
+
+ if is_pdf:
+ meta_info = await asyncio.to_thread(_process_pdf, path, out_dir)
+ title_name = _safe_dirname(meta_info['title'], [meta_info['author']] if meta_info['author'] else None)
+ title_dir = os.path.join(BOOKS_DIR, title_name + "_data")
+ if title_name and title_dir != out_dir and not os.path.exists(title_dir):
+ os.rename(out_dir, title_dir)
+ out_dir = title_dir
+ book_id = os.path.basename(out_dir)
+ return {
+ "success": True,
+ "book_id": book_id,
+ "title": meta_info['title'],
+ "chapters": meta_info['pages'],
+ "has_cover": True,
+ }
+
+ book_obj = await asyncio.to_thread(process_epub, path, out_dir)
+ await asyncio.to_thread(save_to_pickle, book_obj, out_dir)
+
+ # Rename directory to book title if different from filename
+ import shutil
+ title_name = _safe_dirname(book_obj.metadata.title, book_obj.metadata.authors)
+ title_dir = os.path.join(BOOKS_DIR, title_name + "_data")
+ if title_name and title_dir != out_dir and not os.path.exists(title_dir):
+ os.rename(out_dir, title_dir)
+ out_dir = title_dir
+ book_id = os.path.basename(out_dir)
+
+ # Keep a copy of the epub for future reprocessing
+ epub_copy = os.path.join(out_dir, "source.epub")
+ if not os.path.exists(epub_copy):
+ try:
+ shutil.copy2(path, epub_copy)
+ except (OSError, PermissionError):
+ # Apple Books sandbox may block metadata copy; fallback to content-only copy
+ try:
+ shutil.copy(path, epub_copy)
+ except Exception:
+ pass # Non-critical: source.epub is only for reprocessing
+
+ load_book_cached.cache_clear()
+
+ return {
+ "success": True,
+ "book_id": book_id,
+ "title": book_obj.metadata.title,
+ "chapters": len(book_obj.spine),
+ "has_cover": _find_cover_image(book_id) is not None,
+ }
+
+
+@app.post("/api/upload")
+async def upload_epub(file: UploadFile = File(...)):
+ """Upload and process an EPUB or PDF file."""
+ if not file.filename:
+ raise HTTPException(status_code=400, detail="No file provided")
+ fname_lower = file.filename.lower()
+ if not (fname_lower.endswith('.epub') or fname_lower.endswith('.pdf')):
+ raise HTTPException(status_code=400, detail="Only .epub and .pdf files are supported")
+
+ is_pdf = fname_lower.endswith('.pdf')
+ suffix = '.pdf' if is_pdf else '.epub'
+
+ # Save to temp file
+ with tempfile.NamedTemporaryFile(suffix=suffix, delete=False) as tmp:
+ content = await file.read()
+ tmp.write(content)
+ tmp_path = tmp.name
+
+ try:
+ # Determine output dir name
+ base_name = os.path.splitext(file.filename)[0]
+ out_dir = os.path.join(BOOKS_DIR, base_name + "_data")
+
+ if is_pdf:
+ meta_info = await asyncio.to_thread(_process_pdf, tmp_path, out_dir)
+ # Rename directory to title if different from filename
+ title_name = _safe_dirname(meta_info['title'], [meta_info['author']] if meta_info['author'] else None)
+ title_dir = os.path.join(BOOKS_DIR, title_name + "_data")
+ if title_name and title_dir != out_dir and not os.path.exists(title_dir):
+ os.rename(out_dir, title_dir)
+ out_dir = title_dir
+ book_id = os.path.basename(out_dir)
+ return {
+ "success": True,
+ "book_id": book_id,
+ "title": meta_info['title'],
+ "chapters": meta_info['pages'],
+ "has_cover": True,
+ }
+ else:
+ # Process in thread to avoid blocking
+ book_obj = await asyncio.to_thread(process_epub, tmp_path, out_dir)
+ await asyncio.to_thread(save_to_pickle, book_obj, out_dir)
+
+ # Rename directory to book title if different from filename
+ title_name = _safe_dirname(book_obj.metadata.title, book_obj.metadata.authors)
+ title_dir = os.path.join(BOOKS_DIR, title_name + "_data")
+ if title_name and title_dir != out_dir and not os.path.exists(title_dir):
+ os.rename(out_dir, title_dir)
+ out_dir = title_dir
+ book_id = os.path.basename(out_dir)
+
+ # Keep a copy of the epub for future reprocessing
+ import shutil
+ shutil.copy2(tmp_path, os.path.join(out_dir, "source.epub"))
+
+ # Clear LRU cache so new book appears
+ load_book_cached.cache_clear()
+
+ return {
+ "success": True,
+ "book_id": book_id,
+ "title": book_obj.metadata.title,
+ "chapters": len(book_obj.spine),
+ "has_cover": _find_cover_image(book_id) is not None,
+ }
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to process file: {str(e)}")
+ finally:
+ os.unlink(tmp_path)
+
+
+@app.post("/api/reprocess/{book_id}")
+async def reprocess_book(book_id: str):
+ """Reprocess a book from its saved source.epub."""
+ safe_id = os.path.basename(book_id)
+ book_dir = os.path.join(BOOKS_DIR, safe_id)
+ source_epub = os.path.join(book_dir, "source.epub")
+ if not os.path.exists(source_epub):
+ raise HTTPException(status_code=400, detail="No source epub found. Please re-upload the book.")
+
+ # Copy source.epub to a temp file OUTSIDE book_dir,
+ # because process_epub will rmtree the entire book_dir
+ import shutil
+ tmp_fd, tmp_epub = tempfile.mkstemp(suffix='.epub')
+ os.close(tmp_fd)
+ shutil.copy2(source_epub, tmp_epub)
+
+ try:
+ book_obj = await asyncio.to_thread(process_epub, tmp_epub, book_dir)
+ await asyncio.to_thread(save_to_pickle, book_obj, book_dir)
+ # Restore source.epub into the fresh output dir
+ shutil.copy2(tmp_epub, os.path.join(book_dir, "source.epub"))
+ load_book_cached.cache_clear()
+ # Clear AI analysis cache for this book so stale results aren't served
+ stale_keys = [k for k in _analysis_cache if k.startswith(f"{safe_id}:")]
+ for k in stale_keys:
+ del _analysis_cache[k]
+ return {"success": True, "title": book_obj.metadata.title}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Reprocess failed: {str(e)}")
+ finally:
+ if os.path.exists(tmp_epub):
+ os.unlink(tmp_epub)
+
+
+# --- PDF Reader Routes ---
+
+@app.get("/read-pdf/{book_id}", response_class=HTMLResponse)
+async def read_pdf(request: Request, book_id: str):
+ """Render PDF reader page."""
+ safe_id = os.path.basename(book_id)
+ meta_path = os.path.join(BOOKS_DIR, safe_id, "meta.json")
+ if not os.path.exists(meta_path):
+ raise HTTPException(status_code=404, detail="PDF book not found")
+ with open(meta_path, 'r', encoding='utf-8') as f:
+ meta = json.load(f)
+ # Check for display_title in library index
+ index = _build_library_index()
+ display_title = index.get(safe_id, {}).get('display_title')
+ return templates.TemplateResponse("pdf_reader.html", {
+ "request": request,
+ "book_id": safe_id,
+ "title": display_title or meta.get('title', 'Untitled'),
+ "pages": meta.get('pages', 0),
+ "outline_json": json.dumps(meta.get('outline', []), ensure_ascii=False),
+ })
+
+
+@app.get("/api/pdf-file/{book_id}")
+async def serve_pdf_file(book_id: str):
+ """Serve the PDF file for the reader."""
+ safe_id = os.path.basename(book_id)
+ pdf_path = os.path.join(BOOKS_DIR, safe_id, "book.pdf")
+ if not os.path.exists(pdf_path):
+ raise HTTPException(status_code=404, detail="PDF file not found")
+ return FileResponse(pdf_path, media_type="application/pdf")
+
+
+@app.post("/api/pdf-search/{book_id}")
+async def search_pdf(book_id: str, req: dict):
+ """Search text in PDF file using PyMuPDF."""
+ import fitz
+ safe_id = os.path.basename(book_id)
+ pdf_path = os.path.join(BOOKS_DIR, safe_id, "book.pdf")
+ if not os.path.exists(pdf_path):
+ raise HTTPException(status_code=404, detail="PDF file not found")
+
+ query = (req.get("query") or "").strip()
+ if not query:
+ return {"results": []}
+
+ results = []
+ doc = fitz.open(pdf_path)
+ try:
+ for page_num in range(len(doc)):
+ page = doc[page_num]
+ text_instances = page.search_for(query)
+ if text_instances:
+ # Get page text for snippet extraction
+ page_text = page.get_text("text")
+ for rect in text_instances:
+ # Extract snippet around match
+ idx = page_text.lower().find(query.lower())
+ if idx >= 0:
+ start = max(0, idx - 40)
+ end = min(len(page_text), idx + len(query) + 40)
+ snippet = page_text[start:end].replace('\n', ' ').strip()
+ if start > 0:
+ snippet = '...' + snippet
+ if end < len(page_text):
+ snippet = snippet + '...'
+ else:
+ snippet = query
+ results.append({
+ "page": page_num + 1,
+ "snippet": snippet,
+ "rect": [rect.x0, rect.y0, rect.x1, rect.y1],
+ })
+ if len(results) >= 200:
+ break
+ finally:
+ doc.close()
+
+ return {"results": results}
+
+
+@app.post("/api/search-cover/{book_id}")
+async def search_cover_online(book_id: str, req: dict = None):
+ """Search for book cover online using Google Books + Douban."""
+ safe_id = os.path.basename(book_id)
+
+ # Try EPUB first, then PDF meta.json
+ book = load_book_cached(safe_id)
+ meta_path = os.path.join(BOOKS_DIR, safe_id, "meta.json")
+ if not book and not os.path.exists(meta_path):
+ raise HTTPException(status_code=404, detail="Book not found")
+
+ # Allow custom query from user
+ custom_query = (req or {}).get("query", "").strip()
+
+ if custom_query:
+ query = custom_query
+ elif book:
+ title = book.metadata.title
+ authors = ', '.join(book.metadata.authors) if book.metadata.authors else ''
+ query = f"{title} {authors}".strip()
+ else:
+ with open(meta_path, 'r', encoding='utf-8') as f:
+ pdf_meta = json.load(f)
+ query = f"{pdf_meta.get('title', '')} {pdf_meta.get('author', '')}".strip()
+
+ import urllib.parse, urllib.request
+
+ # Detect if query is likely Chinese
+ has_cjk = any('\u4e00' <= ch <= '\u9fff' for ch in query)
+ douban_covers = []
+ google_covers = []
+
+ # --- Douban (better for Chinese books) ---
+ try:
+ dquery = custom_query if custom_query else _re.sub(r'[\\/:*?"<>|]', '', book.metadata.title).strip()
+ durl = f"https://book.douban.com/j/subject_suggest?q={urllib.parse.quote(dquery)}"
+ def _fetch_douban():
+ req = urllib.request.Request(durl, headers={
+ "User-Agent": "Mozilla/5.0",
+ "Referer": "https://book.douban.com/",
+ })
+ with urllib.request.urlopen(req, timeout=8) as resp:
+ return json.loads(resp.read())
+ items = await asyncio.to_thread(_fetch_douban)
+ for item in items[:6]:
+ pic = item.get("pic", "")
+ if pic:
+ img_url = pic.replace("/s/", "/l/")
+ douban_covers.append({
+ "title": item.get("title", ""),
+ "authors": [item["author_name"]] if item.get("author_name") else [],
+ "image_url": img_url,
+ "source": "douban",
+ })
+ except Exception:
+ pass
+
+ # --- Google Books ---
+ try:
+ gurl = f"https://www.googleapis.com/books/v1/volumes?q={urllib.parse.quote(query)}&maxResults=12"
+ def _fetch_google():
+ req = urllib.request.Request(gurl, headers={"User-Agent": "Reader3/1.0"})
+ with urllib.request.urlopen(req, timeout=8) as resp:
+ return json.loads(resp.read())
+ data = await asyncio.to_thread(_fetch_google)
+ for item in data.get("items", []):
+ info = item.get("volumeInfo", {})
+ images = info.get("imageLinks", {})
+ # Prefer highest resolution available
+ img_url = (images.get("extraLarge") or images.get("large") or
+ images.get("medium") or images.get("thumbnail"))
+ if img_url:
+ img_url = img_url.replace("http://", "https://").replace("&edge=curl", "")
+ # Request higher zoom level for better quality
+ img_url = _re.sub(r'zoom=\d', 'zoom=3', img_url)
+ google_covers.append({
+ "title": info.get("title", ""),
+ "authors": info.get("authors", []),
+ "image_url": img_url,
+ })
+ except Exception:
+ pass
+
+ # CJK queries: Douban first; otherwise Google first
+ if has_cjk:
+ covers = douban_covers + google_covers
+ else:
+ covers = google_covers + douban_covers
+
+ return {"covers": covers, "query": query}
+
+
+@app.get("/api/proxy-image")
+async def proxy_image(url: str):
+ """Proxy external images that block direct browser access (e.g. Douban)."""
+ import urllib.request
+ if "doubanio.com" not in url and "douban.com" not in url:
+ raise HTTPException(status_code=400, detail="Only douban images supported")
+ def _fetch():
+ req = urllib.request.Request(url, headers={
+ "User-Agent": "Mozilla/5.0",
+ "Referer": "https://book.douban.com/",
+ })
+ with urllib.request.urlopen(req, timeout=10) as resp:
+ return resp.read(), resp.headers.get("Content-Type", "image/jpeg")
+ try:
+ data, ctype = await asyncio.to_thread(_fetch)
+ return Response(content=data, media_type=ctype)
+ except Exception:
+ raise HTTPException(status_code=502, detail="Failed to fetch image")
+
+
+@app.post("/api/set-cover/{book_id}")
+async def set_cover_from_url(book_id: str, req: dict):
+ """Download an image URL and set it as the book cover."""
+ safe_id = os.path.basename(book_id)
+ images_dir = os.path.join(BOOKS_DIR, safe_id, "images")
+ os.makedirs(images_dir, exist_ok=True)
+
+ image_url = req.get("image_url", "")
+ if not image_url:
+ raise HTTPException(status_code=400, detail="No image URL provided")
+
+ import urllib.request
+ try:
+ def _download():
+ headers = {"User-Agent": "Mozilla/5.0"}
+ # Douban images require Referer header
+ if "doubanio.com" in image_url:
+ headers["Referer"] = "https://book.douban.com/"
+ req_obj = urllib.request.Request(image_url, headers=headers)
+ with urllib.request.urlopen(req_obj, timeout=10) as resp:
+ return resp.read()
+ img_data = await asyncio.to_thread(_download)
+
+ # Auto-trim white borders
+ from PIL import Image, ImageChops
+ import io
+ def _trim_and_save():
+ img = Image.open(io.BytesIO(img_data)).convert("RGB")
+ # Create a white background image, diff to find content area
+ bg = Image.new("RGB", img.size, (255, 255, 255))
+ diff = ImageChops.difference(img, bg)
+ # Tolerance: treat near-white (>240) as white
+ thresh = diff.point(lambda x: 0 if x < 15 else 255)
+ bbox = thresh.getbbox()
+ if bbox:
+ # Only trim if it removes meaningful border (>2% per side)
+ w, h = img.size
+ margin = 0.02
+ if (bbox[0] > w * margin or bbox[1] > h * margin
+ or bbox[2] < w * (1 - margin) or bbox[3] < h * (1 - margin)):
+ img = img.crop(bbox)
+ img.save(cover_path, "JPEG", quality=92)
+
+ cover_path = os.path.join(images_dir, "cover.jpg")
+ await asyncio.to_thread(_trim_and_save)
+
+ # Also write marker
+ marker_path = os.path.join(BOOKS_DIR, safe_id, "cover_image.txt")
+ with open(marker_path, "w") as f:
+ f.write("cover.jpg")
+
+ return {"success": True}
+ except Exception as e:
+ raise HTTPException(status_code=500, detail=f"Failed to download cover: {str(e)}")
+
+
+def auto_import_default_books():
+ """Scan assets/ for specific default EPUBs and import them if not already in library."""
+ default_book = os.path.join("assets", "Meditations by Emperor of Rome Marcus Aurelius.epub")
+ if not os.path.exists(default_book):
+ return
+
+ # Check if already imported (basic folder name check)
+ book_filename = os.path.basename(default_book)
+ book_id = os.path.splitext(book_filename)[0].replace(" ", "_")
+ book_data_path = os.path.join(BOOKS_DIR, book_id)
+
+ if not os.path.exists(book_data_path):
+ print(f"📦 First run detected: Auto-importing '{book_filename}'...")
+ try:
+ # Silence internal prints during auto-import
+ import sys
+ import io
+ old_stdout = sys.stdout
+ sys.stdout = io.StringIO()
+
+ process_epub(default_book, BOOKS_DIR)
+
+ sys.stdout = old_stdout
+ print(f"✅ Successfully imported '{book_filename}'.")
+ except Exception as e:
+ print(f"❌ Failed to auto-import '{book_filename}': {e}")
- return FileResponse(img_path)
if __name__ == "__main__":
import uvicorn
- print("Starting server at http://127.0.0.1:8123")
+ # Perform auto-import before starting server
+ auto_import_default_books()
uvicorn.run(app, host="127.0.0.1", port=8123)
+
diff --git a/templates/library.html b/templates/library.html
index e7d094d3..cf0e8ec3 100644
--- a/templates/library.html
+++ b/templates/library.html
@@ -3,39 +3,1304 @@
- No processed books found. Run reader3.py on an epub first.
No books yet
+Drop an EPUB or PDF here, or import from Apple Books
+