@xiguanpm/inkos-web 1.0.6

package/dist-server/routes/inkos.js

@@ -0,0 +1,1022 @@
+const express = require('express');
+const path = require('path');
+const fs = require('fs');
+const { execInkos, execInkosStream, setWorkDir, getWorkDir, parseTextOutput } = require('../utils/cli');
+const router = express.Router();
+
+router.post('/read-file', async (req, res) => {
+  try {
+    const { path: filePath } = req.body;
+    if (!filePath) {
+      return res.status(400).json({ success: false, error: 'File path is required' });
+    }
+    if (!fs.existsSync(filePath)) {
+      return res.status(404).json({ success: false, error: 'File not found' });
+    }
+    const content = fs.readFileSync(filePath, 'utf-8');
+    res.json({ success: true, data: { content }, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/status', async (req, res) => {
+  try {
+    const result = await execInkos('status --json');
+    if (result.success) {
+      const data = result.data;
+      const response = {
+        projectName: data.projectName || path.basename(getWorkDir()),
+        projectPath: getWorkDir(),
+        books: data.books || [],
+        totalChapters: data.totalChapters || 0,
+        totalWords: data.totalWords || 0,
+        pendingReviews: data.pendingReviews || 0,
+      };
+      res.json({ success: true, data: response, stdout: result.stdout });
+    } else {
+      res.json(result);
+    }
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books', async (req, res) => {
+  try {
+    const result = await execInkos('status --json');
+    res.json(result.success ? { ...result, data: result.data.books || [] } : result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books', async (req, res) => {
+  try {
+    const { title, genre, platform, chapterWords, targetChapters, brief } = req.body;
+    const args = [
+      'book', 'create',
+      '--title', title,
+      '--genre', genre || 'xuanhuan',
+      '--platform', platform || 'tomato',
+      '--chapter-words', String(chapterWords || 3000),
+      '--target-chapters', String(targetChapters || 200)
+    ];
+    
+    if (brief) {
+      args.push('--brief', brief);
+    }
+    
+    const result = await execInkos(args, { timeout: 300000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/books/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const result = await execInkos(['book', 'delete', id, '--force']);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const result = await execInkos(['status', id, '--chapters']);
+
+    if (!result.success) {
+      return res.json(result);
+    }
+
+    const data = result.data;
+    if (data.books && data.books.length > 0) {
+      const bookData = data.books[0];
+
+      const workDir = getWorkDir();
+      const chapterDir = path.join(workDir, 'books', id, 'chapters');
+      let chaptersWithMtime = bookData.chapterList || [];
+
+      if (fs.existsSync(chapterDir)) {
+        const files = fs.readdirSync(chapterDir).filter(f => f.endsWith('.md'));
+        const mtimeMap = {};
+        for (const file of files) {
+          const match = file.match(/^(\d+)_/);
+          if (match) {
+            const num = parseInt(match[1], 10);
+            const filePath = path.join(chapterDir, file);
+            const stats = fs.statSync(filePath);
+            mtimeMap[num] = stats.mtime.toISOString();
+          }
+        }
+        chaptersWithMtime = chaptersWithMtime.map(ch => ({
+          ...ch,
+          updatedAt: mtimeMap[ch.number] || ch.updatedAt || null,
+        }));
+      }
+
+      res.json({
+        success: true,
+        data: {
+          book: {
+            id: bookData.id,
+            title: bookData.title,
+            status: bookData.status,
+            genre: bookData.genre,
+            platform: bookData.platform,
+            targetChapters: bookData.targetChapters,
+            chapterWordCount: bookData.avgWordsPerChapter || 3000,
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+          },
+          chapters: chaptersWithMtime,
+        },
+        stdout: result.stdout,
+      });
+    } else {
+      res.json({ success: false, error: 'Book not found' });
+    }
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id/chapter/:chapter', async (req, res) => {
+  try {
+    const { id, chapter } = req.params;
+    const chapterNum = parseInt(chapter, 10);
+    const workDir = getWorkDir();
+    const chapterDir = path.join(workDir, 'books', id, 'chapters');
+
+    if (!fs.existsSync(chapterDir)) {
+      return res.status(404).json({ success: false, error: 'Chapters directory not found' });
+    }
+
+    const files = fs.readdirSync(chapterDir).filter(f => f.endsWith('.md'));
+
+    let chapterFile = null;
+    for (const file of files) {
+      const match = file.match(/^(\d+)_/);
+      if (match && parseInt(match[1], 10) === chapterNum) {
+        chapterFile = path.join(chapterDir, file);
+        break;
+      }
+    }
+
+    if (!chapterFile || !fs.existsSync(chapterFile)) {
+      return res.status(404).json({ success: false, error: `Chapter ${chapter} not found` });
+    }
+
+    const content = fs.readFileSync(chapterFile, 'utf-8');
+    res.json({ success: true, data: { content }, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.put('/books/:id/chapter/:chapter', async (req, res) => {
+  try {
+    const { id, chapter } = req.params;
+    const { content } = req.body;
+    const chapterNum = parseInt(chapter, 10);
+    const workDir = getWorkDir();
+    const chapterDir = path.join(workDir, 'books', id, 'chapters');
+
+    if (!fs.existsSync(chapterDir)) {
+      return res.status(404).json({ success: false, error: 'Chapters directory not found' });
+    }
+
+    const files = fs.readdirSync(chapterDir).filter(f => f.endsWith('.md'));
+
+    let chapterFile = null;
+    for (const file of files) {
+      const match = file.match(/^(\d+)_/);
+      if (match && parseInt(match[1], 10) === chapterNum) {
+        chapterFile = path.join(chapterDir, file);
+        break;
+      }
+    }
+
+    if (!chapterFile) {
+      return res.status(404).json({ success: false, error: `Chapter ${chapter} not found` });
+    }
+
+    fs.writeFileSync(chapterFile, content, 'utf-8');
+    res.json({ success: true, data: { path: chapterFile }, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.patch('/books/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { chapterWords, targetChapters, status } = req.body;
+    
+    const args = ['book', 'update', id];
+    
+    if (chapterWords) args.push('--chapter-words', String(chapterWords));
+    if (targetChapters) args.push('--target-chapters', String(targetChapters));
+    if (status) args.push('--status', status);
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books/:id/write', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { count = 1, words, context, quiet } = req.body;
+    
+    const args = ['write', 'next', id, '--count', String(count)];
+    
+    if (words) args.push('--words', String(words));
+    if (context) args.push('--context', context);
+    if (quiet) args.push('-q');
+    
+    const result = await execInkos(args, { timeout: 600000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books/:id/rewrite', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { chapter, force, words } = req.body;
+
+    const args = ['write', 'rewrite', id, String(chapter)];
+
+    if (force) args.push('--force');
+    if (words) args.push('--words', String(words));
+
+    execInkos(args, { timeout: 900000 });
+
+    res.json({ success: true, message: '重写任务已提交' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books/:id/draft', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { words, quiet } = req.body;
+    
+    const args = ['draft', id];
+    
+    if (words) args.push('--words', String(words));
+    if (quiet) args.push('-q');
+    
+    const result = await execInkos(args, { timeout: 600000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/review', async (req, res) => {
+  try {
+    const { bookId } = req.query;
+    const args = ['review', 'list'];
+    if (bookId) args.push(bookId);
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/review/approve', async (req, res) => {
+  try {
+    const { bookId, chapter } = req.body;
+    const args = ['review', 'approve'];
+    if (bookId) args.push(bookId);
+    args.push(String(chapter));
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/review/approve-all', async (req, res) => {
+  try {
+    const { bookId } = req.body;
+    const args = ['review', 'approve-all'];
+    if (bookId) args.push(bookId);
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/review/reject', async (req, res) => {
+  try {
+    const { bookId, chapter, reason } = req.body;
+    const args = ['review', 'reject'];
+    if (bookId) args.push(bookId);
+    args.push(String(chapter));
+    if (reason) args.push('--reason', reason);
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id/audit', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { chapter } = req.query;
+    
+    const args = ['audit', id];
+    if (chapter) args.push(String(chapter));
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books/:id/revise', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { chapter, mode } = req.body;
+    
+    const args = ['revise', id];
+    if (chapter) args.push(String(chapter));
+    if (mode) args.push('--mode', mode);
+    
+    const result = await execInkos(args, { timeout: 300000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books/:id/export', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { format, output, approvedOnly } = req.body;
+    
+    const args = ['export', id, '--format', format || 'txt'];
+    if (output) args.push('--output', output);
+    if (approvedOnly) args.push('--approved-only');
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/import/chapters', async (req, res) => {
+  try {
+    const { bookId, from, split, resumeFrom } = req.body;
+    
+    const args = ['import', 'chapters', bookId, '--from', from];
+    if (split) args.push('--split', split);
+    if (resumeFrom) args.push('--resume-from', String(resumeFrom));
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/import/canon', async (req, res) => {
+  try {
+    const { targetBookId, from } = req.body;
+    
+    const args = ['import', 'canon', targetBookId, '--from', from];
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/style/analyze', async (req, res) => {
+  try {
+    const { file } = req.body;
+    const result = await execInkos(['style', 'analyze', file]);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/style/import', async (req, res) => {
+  try {
+    const { file, bookId, name } = req.body;
+    
+    const args = ['style', 'import', file];
+    if (bookId) args.push(bookId);
+    if (name) args.push('--name', name);
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id/detect', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { chapter } = req.query;
+    
+    const args = ['detect', id];
+    if (chapter) args.push(String(chapter));
+    
+    const result = await execInkos(args);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/books/:id/detect-all', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const result = await execInkos(['detect', id, '--all'], { timeout: 600000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id/detect-stats', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const result = await execInkos(['detect', id, '--stats']);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id/analytics', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const result = await execInkos(['analytics', id]);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/radar/scan', async (req, res) => {
+  try {
+    const result = await execInkos(['radar', 'scan'], { timeout: 600000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/radar/history', async (req, res) => {
+  try {
+    const workDir = getWorkDir();
+    const radarDir = path.join(workDir, 'radar');
+    
+    if (!fs.existsSync(radarDir)) {
+      return res.json({ success: true, data: [], stdout: '' });
+    }
+    
+    const files = fs.readdirSync(radarDir).filter(f => f.endsWith('.json'));
+    const history = [];
+    
+    for (const file of files) {
+      try {
+        const filePath = path.join(radarDir, file);
+        const content = fs.readFileSync(filePath, 'utf-8');
+        const data = JSON.parse(content);
+        const stats = fs.statSync(filePath);
+        history.push({
+          fileName: file,
+          filePath: filePath,
+          scannedAt: stats.mtime.toISOString(),
+          createdAt: stats.birthtime.toISOString(),
+          marketSummary: data.marketSummary || '',
+          recommendationCount: data.recommendations ? data.recommendations.length : 0,
+        });
+      } catch (e) {
+        console.error(`[DEBUG] Failed to parse radar file ${file}:`, e.message);
+      }
+    }
+    
+    history.sort((a, b) => new Date(b.scannedAt).getTime() - new Date(a.scannedAt).getTime());
+    
+    res.json({ success: true, data: history, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/radar/:fileName', async (req, res) => {
+  try {
+    const { fileName } = req.params;
+    const workDir = getWorkDir();
+    const filePath = path.join(workDir, 'radar', fileName);
+    
+    if (!filePath.startsWith(path.join(workDir, 'radar'))) {
+      return res.status(403).json({ success: false, error: 'Invalid file path' });
+    }
+    
+    if (!fs.existsSync(filePath)) {
+      return res.status(404).json({ success: false, error: 'File not found' });
+    }
+    
+    const content = fs.readFileSync(filePath, 'utf-8');
+    const data = JSON.parse(content);
+    res.json({ success: true, data, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/genres', async (req, res) => {
+  try {
+    const result = await execInkos(['genre', 'list'], { json: false });
+    if (result.success) {
+      const lines = result.stdout.split('\n');
+      const genres = [];
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed && !trimmed.startsWith('Available') && !trimmed.startsWith('Total:') && trimmed !== '') {
+          const match = trimmed.match(/^(\S+)/);
+          if (match) {
+            genres.push(match[1]);
+          }
+        }
+      }
+      res.json({ success: true, data: genres, stdout: result.stdout });
+    } else {
+      res.json(result);
+    }
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/genres/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const workDir = getWorkDir();
+    const genrePath = path.join(workDir, 'genres', `${id}.md`);
+    console.log(`[DEBUG] Getting genre ${id}, workDir: ${workDir}, genrePath: ${genrePath}`);
+    if (fs.existsSync(genrePath)) {
+      const content = fs.readFileSync(genrePath, 'utf-8');
+      res.json({ success: true, data: { content }, stdout: content });
+    } else {
+      console.log(`[DEBUG] Genre file not found: ${genrePath}, falling back to inkos CLI`);
+      const result = await execInkos(['genre', 'show', id], { json: false });
+      res.json({ success: true, data: { content: result.stdout }, stdout: result.stdout });
+    }
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/genres', async (req, res) => {
+  try {
+    const { name, from } = req.body;
+    const args = ['genre', 'create', name];
+    if (from) {
+      args.push('--from', from);
+    }
+    const result = await execInkos(args, { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.put('/genres/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { content } = req.body;
+    const workDir = getWorkDir();
+    const genrePath = path.join(workDir, 'genres', `${id}.md`);
+    fs.writeFileSync(genrePath, content, 'utf-8');
+    res.json({ success: true, data: { path: genrePath } });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/init', async (req, res) => {
+  try {
+    const { name, path: projectPath, createExample, llmConfig } = req.body;
+    
+    console.log('[DEBUG] /init request body:', req.body);
+    console.log('[DEBUG] projectPath:', projectPath);
+    console.log('[DEBUG] name:', name);
+    
+    let initPath = projectPath;
+    let cwd = getWorkDir();
+    
+    if (projectPath) {
+      cwd = path.dirname(projectPath);
+      initPath = path.basename(projectPath);
+    }
+    
+    const args = ['init'];
+    if (initPath) {
+      args.push(initPath);
+    }
+    
+    console.log('[DEBUG] Final command: inkos', args.join(' '), 'in', cwd);
+    
+    const result = await execInkos(args, { json: false, cwd });
+    
+    if (result.success && llmConfig && projectPath) {
+      const envFilePath = path.join(projectPath, '.env');
+      const envContent = [];
+      
+      // 读取原有 .env 文件内容（如果存在）
+      let existingContent = '';
+      if (fs.existsSync(envFilePath)) {
+        existingContent = fs.readFileSync(envFilePath, 'utf-8');
+      }
+      
+      // 构建新的 LLM 配置
+      const newConfig = [];
+      if (llmConfig.provider) {
+        newConfig.push(`INKOS_LLM_PROVIDER=${llmConfig.provider}`);
+      }
+      if (llmConfig.baseUrl) {
+        newConfig.push(`INKOS_LLM_BASE_URL=${llmConfig.baseUrl}`);
+      }
+      if (llmConfig.apiKey) {
+        newConfig.push(`INKOS_LLM_API_KEY=${llmConfig.apiKey}`);
+      }
+      if (llmConfig.model) {
+        newConfig.push(`INKOS_LLM_MODEL=${llmConfig.model}`);
+      }
+      if (llmConfig.temperature) {
+        newConfig.push(`INKOS_LLM_TEMPERATURE=${llmConfig.temperature}`);
+      }
+      if (llmConfig.maxTokens) {
+        newConfig.push(`INKOS_LLM_MAX_TOKENS=${llmConfig.maxTokens}`);
+      }
+      if (llmConfig.thinkingBudget !== undefined && llmConfig.thinkingBudget !== null) {
+        newConfig.push(`INKOS_LLM_THINKING_BUDGET=${llmConfig.thinkingBudget}`);
+      }
+      
+      // 合并原有内容和新配置
+      if (existingContent) {
+        envContent.push(existingContent);
+      }
+      if (newConfig.length > 0) {
+        envContent.push(newConfig.join('\n'));
+      }
+      
+      if (envContent.length > 0) {
+        fs.writeFileSync(envFilePath, envContent.join('\n'), 'utf-8');
+      }
+    }
+    
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/doctor', async (req, res) => {
+  try {
+    const result = await execInkos(['doctor'], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/config/show', async (req, res) => {
+  try {
+    const result = await execInkos(['config', 'show']);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/config/show-global', async (req, res) => {
+  try {
+    const result = await execInkos(['config', 'show-global'], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/config/models', async (req, res) => {
+  try {
+    const result = await execInkos(['config', 'show-models']);
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/config/set', async (req, res) => {
+  try {
+    const { key, value } = req.body;
+    const result = await execInkos(['config', 'set', key, value], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/config/set-global', async (req, res) => {
+  try {
+    const { provider, baseUrl, apiKey, model } = req.body;
+    
+    const args = ['config', 'set-global'];
+    if (provider) args.push('--provider', provider);
+    if (baseUrl) args.push('--base-url', baseUrl);
+    if (apiKey) args.push('--api-key', apiKey);
+    if (model) args.push('--model', model);
+    
+    const result = await execInkos(args, { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/config/set-model', async (req, res) => {
+  try {
+    const { agent, model, provider, baseUrl, apiKeyEnv } = req.body;
+    
+    const args = ['config', 'set-model', agent, model];
+    if (provider) args.push('--provider', provider);
+    if (baseUrl) args.push('--base-url', baseUrl);
+    if (apiKeyEnv) args.push('--api-key-env', apiKeyEnv);
+    
+    const result = await execInkos(args, { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.delete('/config/remove-model', async (req, res) => {
+  try {
+    const { agent } = req.body;
+    const result = await execInkos(['config', 'remove-model', agent], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/config/project-env', async (req, res) => {
+  try {
+    const projectPath = getWorkDir();
+    const envFilePath = path.join(projectPath, '.env');
+    
+    if (!fs.existsSync(envFilePath)) {
+      return res.json({ success: true, data: {} });
+    }
+    
+    const envContent = fs.readFileSync(envFilePath, 'utf-8');
+    const envConfig = {};
+    
+    envContent.split('\n').forEach(line => {
+      const trimmedLine = line.trim();
+      if (trimmedLine && !trimmedLine.startsWith('#')) {
+        const [key, ...valueParts] = trimmedLine.split('=');
+        const value = valueParts.join('=');
+        if (key && value !== undefined) {
+          envConfig[key.trim()] = value.trim();
+        }
+      }
+    });
+    
+    res.json({ success: true, data: envConfig });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/config/project-env', async (req, res) => {
+  try {
+    const projectPath = getWorkDir();
+    const envFilePath = path.join(projectPath, '.env');
+    const updates = req.body;
+    
+    let existingContent = '';
+    if (fs.existsSync(envFilePath)) {
+      existingContent = fs.readFileSync(envFilePath, 'utf-8');
+    }
+    
+    const existingLines = existingContent.split('\n');
+    const updatedKeys = new Set(Object.keys(updates));
+    const preservedLines = [];
+    
+    existingLines.forEach(line => {
+      const trimmedLine = line.trim();
+      if (trimmedLine && !trimmedLine.startsWith('#')) {
+        const [key] = trimmedLine.split('=');
+        if (key && !updatedKeys.has(key.trim())) {
+          preservedLines.push(line);
+        }
+      } else if (trimmedLine.startsWith('#') || trimmedLine === '') {
+        preservedLines.push(line);
+      }
+    });
+    
+    const newLines = Object.entries(updates).map(([key, value]) => {
+      if (value !== null && value !== undefined && value !== '') {
+        return `${key}=${value}`;
+      }
+      return null;
+    }).filter(line => line !== null);
+    
+    const finalContent = [...preservedLines, ...newLines].join('\n');
+    fs.writeFileSync(envFilePath, finalContent, 'utf-8');
+    
+    res.json({ success: true, message: '配置已保存' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/daemon/up', async (req, res) => {
+  try {
+    const { quiet } = req.body;
+    const args = ['up'];
+    if (quiet) args.push('-q');
+    
+    const result = await execInkos(args, { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/daemon/down', async (req, res) => {
+  try {
+    const result = await execInkos(['down'], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/agent', async (req, res) => {
+  try {
+    const { instruction } = req.body;
+    const result = await execInkos(['agent', instruction], { timeout: 600000 });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/version', async (req, res) => {
+  try {
+    const result = await execInkos(['--version'], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/update', async (req, res) => {
+  try {
+    const result = await execInkos(['update'], { json: false });
+    res.json(result);
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.post('/work-dir', (req, res) => {
+  try {
+    const { path: workPath } = req.body;
+    if (setWorkDir(workPath)) {
+      res.json({ success: true, data: { workDir: getWorkDir() } });
+    } else {
+      res.json({ success: false, error: 'Invalid directory path' });
+    }
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/work-dir', (req, res) => {
+  res.json({ success: true, data: { workDir: getWorkDir() } });
+});
+
+router.get('/books/:id/truth-files', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const workDir = getWorkDir();
+    const truthDir = path.join(workDir, 'books', id, 'story');
+
+    if (!fs.existsSync(truthDir)) {
+      return res.json({ success: true, data: [], stdout: '' });
+    }
+
+    const truthFiles = [
+      'current_state.md',
+      'particle_ledger.md',
+      'pending_hooks.md',
+      'chapter_summaries.md',
+      'subplot_board.md',
+      'emotional_arcs.md',
+      'character_matrix.md',
+    ];
+
+    const files = [];
+    for (const file of truthFiles) {
+      const filePath = path.join(truthDir, file);
+      if (fs.existsSync(filePath)) {
+        const stats = fs.statSync(filePath);
+        files.push({
+          name: file,
+          path: filePath,
+          size: stats.size,
+          mtime: stats.mtime.toISOString(),
+        });
+      }
+    }
+
+    res.json({ success: true, data: files, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.get('/books/:id/truth-file', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { file } = req.query;
+
+    if (!file) {
+      return res.status(400).json({ success: false, error: 'File name is required' });
+    }
+
+    const workDir = getWorkDir();
+    const filePath = path.join(workDir, 'books', id, 'story', file);
+
+    if (!filePath.startsWith(path.join(workDir, 'books', id, 'story'))) {
+      return res.status(403).json({ success: false, error: 'Invalid file path' });
+    }
+
+    if (!fs.existsSync(filePath)) {
+      return res.status(404).json({ success: false, error: 'File not found' });
+    }
+
+    const content = fs.readFileSync(filePath, 'utf-8');
+    res.json({ success: true, data: { content, path: filePath }, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+router.put('/books/:id/truth-file', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const { file, content } = req.body;
+
+    if (!file) {
+      return res.status(400).json({ success: false, error: 'File name is required' });
+    }
+
+    const workDir = getWorkDir();
+    const filePath = path.join(workDir, 'books', id, 'story', file);
+
+    if (!filePath.startsWith(path.join(workDir, 'books', id, 'story'))) {
+      return res.status(403).json({ success: false, error: 'Invalid file path' });
+    }
+
+    fs.writeFileSync(filePath, content, 'utf-8');
+    res.json({ success: true, data: { path: filePath }, stdout: '' });
+  } catch (error) {
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+module.exports = router;