|
|
import express from 'express'
|
|
|
import { spawn } from 'child_process'
|
|
|
import fs from 'fs'
|
|
|
import path from 'path'
|
|
|
import { fileURLToPath } from 'url'
|
|
|
|
|
|
const __dirname = path.dirname(fileURLToPath(import.meta.url))
|
|
|
const CONFIG_DIR = path.join(__dirname, '.config')
|
|
|
const CONFIG_FILE = path.join(CONFIG_DIR, 'ai-config.json')
|
|
|
|
|
|
// Ensure config directory exists
|
|
|
if (!fs.existsSync(CONFIG_DIR)) {
|
|
|
fs.mkdirSync(CONFIG_DIR, { recursive: true })
|
|
|
}
|
|
|
|
|
|
// Load config from file
|
|
|
function loadConfig() {
|
|
|
try {
|
|
|
if (fs.existsSync(CONFIG_FILE)) {
|
|
|
return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'))
|
|
|
}
|
|
|
} catch (e) {
|
|
|
console.error('Failed to load config:', e)
|
|
|
}
|
|
|
return {
|
|
|
provider: 'aliyun',
|
|
|
apiKey: '',
|
|
|
model: 'qwen3.6-plus',
|
|
|
baseUrl: 'https://coding.dashscope.aliyuncs.com/v1',
|
|
|
temperature: 0.7,
|
|
|
maxTokens: 8000
|
|
|
}
|
|
|
}
|
|
|
|
|
|
// Save config to file
|
|
|
function saveConfig(config) {
|
|
|
try {
|
|
|
fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf-8')
|
|
|
return true
|
|
|
} catch (e) {
|
|
|
console.error('Failed to save config:', e)
|
|
|
return false
|
|
|
}
|
|
|
}
|
|
|
|
|
|
import cors from 'cors'
|
|
|
|
|
|
// 导入路由
|
|
|
import authRoutes from './src/routes/auth.js'
|
|
|
import plansRoutes from './src/routes/plans.js'
|
|
|
import statsRoutes from './src/routes/stats.js'
|
|
|
|
|
|
const app = express()
|
|
|
app.use(cors({
|
|
|
origin: 'http://localhost:5173',
|
|
|
methods: ['GET', 'POST', 'OPTIONS', 'DELETE'],
|
|
|
allowedHeaders: ['Content-Type', 'Authorization'],
|
|
|
exposedHeaders: ['Content-Type']
|
|
|
}))
|
|
|
app.use(express.json())
|
|
|
|
|
|
// 注册路由
|
|
|
app.use('/api/auth', authRoutes)
|
|
|
app.use('/api/plans', plansRoutes)
|
|
|
app.use('/api/stats', statsRoutes)
|
|
|
|
|
|
// API: Get config
|
|
|
app.get('/api/config', (req, res) => {
|
|
|
const config = loadConfig()
|
|
|
// Don't expose full API key in GET request
|
|
|
res.json({
|
|
|
...config,
|
|
|
apiKey: config.apiKey ? config.apiKey.slice(0, 8) + '********' : ''
|
|
|
})
|
|
|
})
|
|
|
|
|
|
// API: Check if API key is configured
|
|
|
app.get('/api/config/check', (req, res) => {
|
|
|
const config = loadConfig()
|
|
|
res.json({ configured: !!config.apiKey })
|
|
|
})
|
|
|
|
|
|
// API: Update config
|
|
|
app.post('/api/config', (req, res) => {
|
|
|
const currentConfig = loadConfig()
|
|
|
const updates = req.body
|
|
|
|
|
|
// If updating API key, use the new value; otherwise keep existing
|
|
|
const newConfig = {
|
|
|
...currentConfig,
|
|
|
...updates,
|
|
|
apiKey: updates.apiKey || currentConfig.apiKey
|
|
|
}
|
|
|
|
|
|
if (saveConfig(newConfig)) {
|
|
|
res.json({ success: true })
|
|
|
} else {
|
|
|
res.status(500).json({ success: false, message: 'Failed to save config' })
|
|
|
}
|
|
|
})
|
|
|
|
|
|
// API: Test connection
|
|
|
app.post('/api/config/test', async (req, res) => {
|
|
|
const { apiKey, model, baseUrl } = req.body
|
|
|
const config = loadConfig()
|
|
|
|
|
|
const testApiKey = apiKey || config.apiKey
|
|
|
const testModel = model || config.model
|
|
|
const testBaseUrl = baseUrl || config.baseUrl
|
|
|
|
|
|
if (!testApiKey) {
|
|
|
return res.json({ success: false, message: '请先输入 API Key' })
|
|
|
}
|
|
|
|
|
|
try {
|
|
|
const response = await fetch(`${testBaseUrl}/chat/completions`, {
|
|
|
method: 'POST',
|
|
|
headers: {
|
|
|
'Content-Type': 'application/json',
|
|
|
'Authorization': `Bearer ${testApiKey}`
|
|
|
},
|
|
|
body: JSON.stringify({
|
|
|
model: testModel,
|
|
|
messages: [{ role: 'user', content: '你好，请回复OK' }],
|
|
|
max_tokens: 10
|
|
|
})
|
|
|
})
|
|
|
|
|
|
const data = await response.json()
|
|
|
|
|
|
if (response.ok && data.choices) {
|
|
|
res.json({ success: true, message: `连接成功！模型: ${data.model || testModel}` })
|
|
|
} else {
|
|
|
res.json({ success: false, message: data.error?.message || '连接失败' })
|
|
|
}
|
|
|
} catch (error) {
|
|
|
res.json({ success: false, message: `网络错误: ${error.message}` })
|
|
|
}
|
|
|
})
|
|
|
|
|
|
// API: Proxy AI chat request (keeps API key on server)
|
|
|
app.post('/api/chat', async (req, res) => {
|
|
|
console.log('[api/chat] POST received, body:', JSON.stringify(req.body).substring(0, 100))
|
|
|
const config = loadConfig()
|
|
|
|
|
|
if (!config.apiKey) {
|
|
|
return res.status(401).json({ error: { message: '请先配置 AI API Key（访问 /settings）' } })
|
|
|
}
|
|
|
|
|
|
// Handle client disconnect
|
|
|
let clientDisconnected = false
|
|
|
req.socket.on('close', () => {
|
|
|
clientDisconnected = true
|
|
|
console.log('[api/chat] Client socket closed')
|
|
|
})
|
|
|
|
|
|
try {
|
|
|
const response = await fetch(`${config.baseUrl}/chat/completions`, {
|
|
|
method: 'POST',
|
|
|
headers: {
|
|
|
'Content-Type': 'application/json',
|
|
|
'Authorization': `Bearer ${config.apiKey}`
|
|
|
},
|
|
|
body: JSON.stringify({
|
|
|
...req.body,
|
|
|
model: req.body.model || config.model,
|
|
|
temperature: req.body.temperature ?? config.temperature,
|
|
|
max_tokens: req.body.max_tokens || config.maxTokens
|
|
|
})
|
|
|
})
|
|
|
|
|
|
if (!response.ok) {
|
|
|
const error = await response.json().catch(() => ({}))
|
|
|
return res.status(response.status).json(error)
|
|
|
}
|
|
|
|
|
|
console.log('[api/chat] AI response status:', response.status)
|
|
|
|
|
|
// Stream the response to client
|
|
|
res.setHeader('Content-Type', 'application/x-ndjson')
|
|
|
res.setHeader('Cache-Control', 'no-cache')
|
|
|
res.setHeader('Connection', 'keep-alive')
|
|
|
res.setHeader('X-Accel-Buffering', 'no')
|
|
|
console.log('[api/chat] Streaming started')
|
|
|
|
|
|
const reader = response.body.getReader()
|
|
|
const decoder = new TextDecoder()
|
|
|
let totalBytes = 0
|
|
|
let chunkCount = 0
|
|
|
|
|
|
while (true) {
|
|
|
if (clientDisconnected) {
|
|
|
reader.cancel()
|
|
|
return
|
|
|
}
|
|
|
const { done, value } = await reader.read()
|
|
|
if (done) break
|
|
|
|
|
|
const chunk = decoder.decode(value, { stream: true })
|
|
|
totalBytes += chunk.length
|
|
|
chunkCount++
|
|
|
|
|
|
res.write(chunk)
|
|
|
|
|
|
if (chunkCount % 10 === 0) {
|
|
|
console.log('[api/chat] Chunk count:', chunkCount, 'bytes:', totalBytes)
|
|
|
}
|
|
|
}
|
|
|
|
|
|
console.log('[api/chat] Streaming done, total chunks:', chunkCount, 'bytes:', totalBytes)
|
|
|
res.end()
|
|
|
} catch (error) {
|
|
|
if (!clientDisconnected) {
|
|
|
res.status(500).json({ error: { message: `请求失败: ${error.message}` } })
|
|
|
}
|
|
|
}
|
|
|
})
|
|
|
|
|
|
// Catch-all for debugging
|
|
|
app.all('/api/*', (req, res) => {
|
|
|
console.log('[DEBUG CATCH-ALL]', req.method, req.path)
|
|
|
res.status(404).json({ error: 'Route not found' })
|
|
|
})
|
|
|
|
|
|
async function start() {
|
|
|
const isDev = process.env.NODE_ENV !== 'production'
|
|
|
|
|
|
if (isDev) {
|
|
|
console.log('[Server] Starting Vite dev server...')
|
|
|
// Run Vite dev server on port 5173
|
|
|
// API routes are handled by Express on port 3001
|
|
|
// We use a simple approach: start both servers
|
|
|
const viteProcess = spawn('npx', ['vite'], {
|
|
|
stdio: 'inherit',
|
|
|
shell: true,
|
|
|
env: { ...process.env, NODE_ENV: 'development' }
|
|
|
})
|
|
|
|
|
|
viteProcess.on('error', (err) => {
|
|
|
console.error('[Server] Failed to start Vite:', err)
|
|
|
})
|
|
|
|
|
|
// Start Express API server on port 3001
|
|
|
const apiPort = 3001
|
|
|
app.listen(apiPort, () => {
|
|
|
console.log(`[Server] API server running at http://localhost:${apiPort}`)
|
|
|
console.log(`[Server] API Key stored in: ${CONFIG_FILE}`)
|
|
|
})
|
|
|
} else {
|
|
|
// Production: serve static files
|
|
|
app.use(express.static(path.join(__dirname, 'dist')))
|
|
|
|
|
|
const port = process.env.PORT || 3000
|
|
|
app.listen(port, () => {
|
|
|
console.log(`Server running on port ${port}`)
|
|
|
})
|
|
|
}
|
|
|
}
|
|
|
|
|
|
start()
|
