746 lines
31 KiB
TypeScript
746 lines
31 KiB
TypeScript
import { randomBytes } from 'node:crypto'
|
|
import { createServer, type IncomingMessage, type ServerResponse } from 'node:http'
|
|
import { parse as parseUrl } from 'node:url'
|
|
import { AuthError, AuthService, MemoryAuthRepository, type AuthRepository } from './auth.js'
|
|
import { CatalogService, MemoryCatalogRepository, type CallMode, type ModelType, type ProviderProtocol, type ProviderSourceType } from './catalog.js'
|
|
import { OpenAICompatibleProvider, OpenAICompatibleProviderError } from './providers/openai-compatible.js'
|
|
import { SeedanceProvider, SeedanceProviderError } from './providers/seedance.js'
|
|
import { TripoProvider, TripoProviderError } from './providers/tripo.js'
|
|
|
|
const config = {
|
|
host: process.env.CONTROL_PLANE_HOST || '127.0.0.1',
|
|
port: Number(process.env.CONTROL_PLANE_PORT || 8787),
|
|
corsOrigins: (process.env.CONTROL_PLANE_CORS_ORIGINS || 'http://localhost:5173').split(',').map((origin) => origin.trim()).filter(Boolean),
|
|
sessionTtlHours: Number(process.env.SESSION_TTL_HOURS || 168),
|
|
passwordPepper: process.env.AUTH_PASSWORD_PEPPER || 'development-only-pepper',
|
|
databaseUrl: process.env.DATABASE_URL,
|
|
nodeEnv: process.env.NODE_ENV || 'development',
|
|
tripoApiKey: process.env.TRIPO_API_KEY,
|
|
tripoBaseUrl: process.env.TRIPO_BASE_URL,
|
|
deepseekApiKey: process.env.DEEPSEEK_API_KEY,
|
|
deepseekBaseUrl: process.env.DEEPSEEK_BASE_URL || 'https://api.deepseek.com',
|
|
deepseekFlashModel: process.env.DEEPSEEK_FLASH_MODEL || 'deepseek-v4-flash',
|
|
deepseekProModel: process.env.DEEPSEEK_PRO_MODEL || 'deepseek-v4-pro',
|
|
kimiApiKey: process.env.KIMI_API_KEY,
|
|
kimiBaseUrl: process.env.KIMI_BASE_URL || 'https://api.moonshot.cn/v1',
|
|
kimiPrimaryModel: process.env.KIMI_PRIMARY_MODEL || 'kimi-k3',
|
|
kimiFallbackModel: process.env.KIMI_FALLBACK_MODEL || 'kimi-k2.6',
|
|
zhipuApiKey: process.env.ZHIPU_API_KEY,
|
|
zhipuBaseUrl: process.env.ZHIPU_BASE_URL || 'https://open.bigmodel.cn/api/paas/v4',
|
|
zhipuPrimaryModel: process.env.ZHIPU_PRIMARY_MODEL || 'glm-4.5',
|
|
zhipuVisionModel: process.env.ZHIPU_VISION_MODEL || 'glm-4.5v',
|
|
seedanceApiKey: process.env.VOLCENGINE_API_KEY,
|
|
seedanceBaseUrl: process.env.VOLCENGINE_BASE_URL,
|
|
seedanceModel: process.env.SEEDANCE_MODEL || 'doubao-seedance-1-0-pro-250528',
|
|
}
|
|
|
|
let repository: AuthRepository = new MemoryAuthRepository()
|
|
if (config.databaseUrl) {
|
|
const { PostgresAuthRepository } = await import('./postgres.js')
|
|
repository = new PostgresAuthRepository(config.databaseUrl)
|
|
}
|
|
const auth = new AuthService(repository, {
|
|
sessionTtlHours: config.sessionTtlHours,
|
|
passwordPepper: config.passwordPepper,
|
|
})
|
|
const catalog = new CatalogService(new MemoryCatalogRepository())
|
|
type UsageEvent = {
|
|
id: string
|
|
userId: string
|
|
kind: 'call' | 'task'
|
|
model: string
|
|
status: 'queued' | 'running' | 'succeeded' | 'failed'
|
|
createdAt: string
|
|
updatedAt: string
|
|
latencyMs?: number
|
|
taskId?: string
|
|
inputUnits?: number
|
|
outputUnits?: number
|
|
}
|
|
type MockTask = {
|
|
id: string
|
|
userId: string
|
|
model: string
|
|
status: 'queued' | 'running' | 'succeeded'
|
|
createdAt: string
|
|
updatedAt: string
|
|
result?: { format: string; url: string }
|
|
}
|
|
const mockTasks = new Map<string, MockTask>()
|
|
const usageEvents: UsageEvent[] = []
|
|
const tripo = config.tripoApiKey ? new TripoProvider({
|
|
apiKey: config.tripoApiKey,
|
|
...(config.tripoBaseUrl ? { baseUrl: config.tripoBaseUrl } : {}),
|
|
}) : undefined
|
|
const openaiProviders = new Map<string, OpenAICompatibleProvider>()
|
|
if (config.deepseekApiKey) openaiProviders.set('provider-deepseek', new OpenAICompatibleProvider({ providerName: 'DeepSeek', apiKey: config.deepseekApiKey, baseUrl: config.deepseekBaseUrl }))
|
|
if (config.kimiApiKey) openaiProviders.set('provider-kimi', new OpenAICompatibleProvider({ providerName: 'Kimi', apiKey: config.kimiApiKey, baseUrl: config.kimiBaseUrl }))
|
|
if (config.zhipuApiKey) openaiProviders.set('provider-zhipu', new OpenAICompatibleProvider({ providerName: '智谱 GLM', apiKey: config.zhipuApiKey, baseUrl: config.zhipuBaseUrl }))
|
|
const seedance = config.seedanceApiKey ? new SeedanceProvider({ apiKey: config.seedanceApiKey, ...(config.seedanceBaseUrl ? { baseUrl: config.seedanceBaseUrl } : {}) }) : undefined
|
|
const upstreamModelOverrides = new Map<string, string>([
|
|
['model-deepseek-v4-flash', config.deepseekFlashModel],
|
|
['model-deepseek-v4-pro', config.deepseekProModel],
|
|
['model-kimi-k3', config.kimiPrimaryModel],
|
|
['model-kimi-k2-6', config.kimiFallbackModel],
|
|
['model-glm-4-5', config.zhipuPrimaryModel],
|
|
['model-glm-4-5v', config.zhipuVisionModel],
|
|
['model-seedance-1-0-pro', config.seedanceModel],
|
|
])
|
|
const tripoTaskOwners = new Map<string, { userId: string; model: string }>()
|
|
const seedanceTaskOwners = new Map<string, { userId: string; model: string }>()
|
|
|
|
if (config.nodeEnv === 'production' && (!process.env.AUTH_PASSWORD_PEPPER || process.env.AUTH_PASSWORD_PEPPER.length < 32)) {
|
|
throw new Error('AUTH_PASSWORD_PEPPER must contain at least 32 characters in production')
|
|
}
|
|
|
|
if (!config.databaseUrl) {
|
|
await auth.ensureAdmin(
|
|
process.env.ADMIN_ACCOUNT || 'demo@moyi.ai',
|
|
process.env.ADMIN_PASSWORD || 'moyi-demo',
|
|
process.env.ADMIN_DISPLAY_NAME || '林默',
|
|
)
|
|
}
|
|
|
|
const authAttempts = new Map<string, { count: number; resetAt: number }>()
|
|
|
|
const server = createServer(async (request, response) => {
|
|
const origin = request.headers.origin
|
|
if (origin && config.corsOrigins.includes(origin)) {
|
|
response.setHeader('Access-Control-Allow-Origin', origin)
|
|
response.setHeader('Access-Control-Allow-Credentials', 'true')
|
|
response.setHeader('Vary', 'Origin')
|
|
}
|
|
if (request.method === 'OPTIONS') {
|
|
response.setHeader('Access-Control-Allow-Headers', 'Content-Type, Authorization')
|
|
response.setHeader('Access-Control-Allow-Methods', 'GET,POST,OPTIONS')
|
|
response.writeHead(204)
|
|
response.end()
|
|
return
|
|
}
|
|
|
|
try {
|
|
await route(request, response)
|
|
} catch (error) {
|
|
handleError(response, error)
|
|
}
|
|
})
|
|
|
|
server.listen(config.port, config.host, () => {
|
|
console.log(`MOYI Control Plane listening on http://${config.host}:${config.port}`)
|
|
console.log(config.databaseUrl ? 'Persistence: PostgreSQL' : 'Persistence: in-memory development store')
|
|
console.log(tripo ? 'Tripo 3D Provider: enabled' : 'Tripo 3D Provider: mock mode')
|
|
console.log(`OpenAI-compatible Providers: ${openaiProviders.size ? [...openaiProviders.keys()].join(', ') : 'none configured'}`)
|
|
console.log(seedance ? 'Seedance Provider: enabled' : 'Seedance Provider: not configured')
|
|
})
|
|
|
|
async function route(request: IncomingMessage, response: ServerResponse) {
|
|
const parsed = parseUrl(request.url || '/', true)
|
|
const method = request.method || 'GET'
|
|
const path = parsed.pathname || '/'
|
|
const meta = {
|
|
...(request.socket.remoteAddress ? { ipAddress: request.socket.remoteAddress } : {}),
|
|
...(request.headers['user-agent'] ? { userAgent: request.headers['user-agent'] } : {}),
|
|
}
|
|
const token = readCookie(request.headers.cookie, 'moyi_session')
|
|
|
|
if (method === 'GET' && path === '/v1/models') {
|
|
const keyRecord = await authenticatePlatformKey(request)
|
|
const models = await catalog.listModels()
|
|
send(response, 200, {
|
|
object: 'list',
|
|
data: models.filter((model) => catalog.canInvoke(keyRecord, model.id)).map((model) => ({
|
|
id: model.id,
|
|
object: 'model',
|
|
owned_by: model.providerId,
|
|
type: model.type,
|
|
mode: model.mode,
|
|
})),
|
|
})
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/v1/chat/completions') {
|
|
const startedAt = Date.now()
|
|
const keyRecord = await authenticatePlatformKey(request)
|
|
const body = await readJson(request)
|
|
const modelId = stringValue(body.model)
|
|
const model = await catalogModel(modelId)
|
|
if (model.mode === 'async') throw new AuthError('ASYNC_MODEL', '该模型需要使用异步任务接口', 400)
|
|
if (!catalog.canInvoke(keyRecord, model.id)) throw new AuthError('MODEL_FORBIDDEN', '当前 Key 无权调用该模型', 403)
|
|
if (model.providerId !== 'provider-mock') {
|
|
const provider = openaiProviders.get(model.providerId)
|
|
if (!provider) throw new AuthError('PROVIDER_NOT_CONFIGURED', '该模型的供应商尚未配置服务端 API Key', 503)
|
|
if (body.stream === true) throw new AuthError('STREAM_NOT_IMPLEMENTED', '该供应商的流式转发将在下一节点开放', 501)
|
|
const upstream = await provider.chatCompletion({
|
|
model: upstreamModelOverrides.get(model.id) || model.upstreamModel,
|
|
messages: Array.isArray(body.messages) ? body.messages as Array<{ role: string; content: unknown }> : [],
|
|
})
|
|
const upstreamContent = upstream.choices?.[0]?.message?.content || ''
|
|
const completedAt = new Date().toISOString()
|
|
usageEvents.push({
|
|
id: `usage_${randomToken(14)}`,
|
|
userId: keyRecord.userId,
|
|
kind: 'call',
|
|
model: model.id,
|
|
status: 'succeeded',
|
|
createdAt: completedAt,
|
|
updatedAt: completedAt,
|
|
latencyMs: Date.now() - startedAt,
|
|
inputUnits: extractPrompt(body.messages).length,
|
|
outputUnits: upstreamContent.length,
|
|
})
|
|
send(response, 200, { ...upstream, model: model.id })
|
|
return
|
|
}
|
|
const prompt = extractPrompt(body.messages)
|
|
const content = `MOYI Mock 已收到:${prompt || '(空消息)'}`
|
|
const completedAt = new Date().toISOString()
|
|
usageEvents.push({
|
|
id: `usage_${randomToken(14)}`,
|
|
userId: keyRecord.userId,
|
|
kind: 'call',
|
|
model: model.id,
|
|
status: 'succeeded',
|
|
createdAt: completedAt,
|
|
updatedAt: completedAt,
|
|
latencyMs: Date.now() - startedAt,
|
|
inputUnits: prompt.length,
|
|
outputUnits: content.length,
|
|
})
|
|
send(response, 200, {
|
|
id: `chatcmpl-${randomToken(10)}`,
|
|
object: 'chat.completion',
|
|
created: Math.floor(Date.now() / 1000),
|
|
model: model.id,
|
|
choices: [{ index: 0, message: { role: 'assistant', content }, finish_reason: 'stop' }],
|
|
usage: { prompt_tokens: prompt.length, completion_tokens: content.length, total_tokens: prompt.length + content.length },
|
|
})
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && (path === '/v1/3d/tasks' || path === '/v1/video/tasks')) {
|
|
const keyRecord = await authenticatePlatformKey(request)
|
|
const body = await readJson(request)
|
|
const modelId = stringValue(body.model)
|
|
const model = await catalogModel(modelId)
|
|
if ((!['3d', 'video'].includes(model.type) || model.mode !== 'async')) throw new AuthError('NOT_ASYNC_MEDIA_MODEL', '该模型不是异步媒体模型', 400)
|
|
if (!catalog.canInvoke(keyRecord, model.id)) throw new AuthError('MODEL_FORBIDDEN', '当前 Key 无权调用该模型', 403)
|
|
if (model.type === 'video') {
|
|
if (!seedance) throw new AuthError('PROVIDER_NOT_CONFIGURED', 'Seedance 尚未配置服务端 API Key', 503)
|
|
const taskId = await seedance.createTextToVideo({ model: upstreamModelOverrides.get(model.id) || model.upstreamModel, prompt: stringValue(body.prompt) })
|
|
seedanceTaskOwners.set(taskId, { userId: keyRecord.userId, model: model.id })
|
|
recordTaskUsage(keyRecord.userId, model.id, taskId, 'queued')
|
|
send(response, 202, { task: { id: taskId, provider: 'seedance', model: model.id, status: 'queued', progress: 0, createdAt: new Date().toISOString() } })
|
|
return
|
|
}
|
|
if (tripo) {
|
|
const prompt = stringValue(body.prompt).trim()
|
|
if (!prompt) throw new AuthError('PROMPT_REQUIRED', '3D 生成提示词不能为空')
|
|
const taskId = await tripo.createTextToModel({
|
|
prompt,
|
|
model: stringValue(body.providerModel) || 'v3.1-20260211',
|
|
...(body.negativePrompt ? { negative_prompt: stringValue(body.negativePrompt) } : {}),
|
|
...(body.faceLimit !== undefined ? { face_limit: numberValue(body.faceLimit, 'faceLimit') } : {}),
|
|
...(body.texture !== undefined ? { texture: booleanValue(body.texture, 'texture') } : {}),
|
|
...(body.pbr !== undefined ? { pbr: booleanValue(body.pbr, 'pbr') } : {}),
|
|
...(body.smartLowPoly !== undefined ? { smart_low_poly: booleanValue(body.smartLowPoly, 'smartLowPoly') } : {}),
|
|
})
|
|
tripoTaskOwners.set(taskId, { userId: keyRecord.userId, model: model.id })
|
|
recordTaskUsage(keyRecord.userId, model.id, taskId, 'queued')
|
|
send(response, 202, {
|
|
task: {
|
|
id: taskId,
|
|
provider: 'tripo',
|
|
model: model.id,
|
|
status: 'queued',
|
|
progress: 0,
|
|
createdAt: new Date().toISOString(),
|
|
},
|
|
})
|
|
return
|
|
}
|
|
const now = new Date().toISOString()
|
|
const task: MockTask = { id: `task_${randomToken(14)}`, userId: keyRecord.userId, model: model.id, status: 'queued', createdAt: now, updatedAt: now }
|
|
mockTasks.set(task.id, task)
|
|
recordTaskUsage(keyRecord.userId, model.id, task.id, 'queued')
|
|
setTimeout(() => {
|
|
const current = mockTasks.get(task.id)
|
|
if (!current) return
|
|
const updatedAt = new Date().toISOString()
|
|
mockTasks.set(task.id, { ...current, status: 'succeeded', updatedAt, result: { format: 'glb', url: `https://mock.moyi.ai/tasks/${task.id}/result.glb` } })
|
|
updateTaskUsage(task.id, 'succeeded', updatedAt)
|
|
}, 500)
|
|
send(response, 202, { task: publicTask(task) })
|
|
return
|
|
}
|
|
|
|
const taskMatch = path.match(/^\/v1\/tasks\/([^/]+)$/)
|
|
const taskId = taskMatch?.[1]
|
|
if (method === 'GET' && taskId) {
|
|
const keyRecord = await authenticatePlatformKey(request)
|
|
const seedanceOwner = seedanceTaskOwners.get(taskId)
|
|
if (seedance && seedanceOwner) {
|
|
if (seedanceOwner.userId !== keyRecord.userId) throw new AuthError('TASK_NOT_FOUND', '任务不存在', 404)
|
|
const providerTask = await seedance.getTask(taskId)
|
|
if (providerTask.status === 'queued' || providerTask.status === 'running' || providerTask.status === 'succeeded' || providerTask.status === 'failed') {
|
|
updateTaskUsage(taskId, providerTask.status)
|
|
}
|
|
send(response, 200, { task: { ...providerTask, model: seedanceOwner.model } })
|
|
return
|
|
}
|
|
const tripoOwner = tripoTaskOwners.get(taskId)
|
|
if (tripo && tripoOwner) {
|
|
if (tripoOwner.userId !== keyRecord.userId) throw new AuthError('TASK_NOT_FOUND', '任务不存在', 404)
|
|
const providerTask = await tripo.getTask(taskId)
|
|
if (providerTask.status === 'queued' || providerTask.status === 'running' || providerTask.status === 'succeeded' || providerTask.status === 'failed') {
|
|
updateTaskUsage(taskId, providerTask.status)
|
|
}
|
|
send(response, 200, { task: { ...providerTask, model: tripoOwner.model } })
|
|
return
|
|
}
|
|
const task = mockTasks.get(taskId)
|
|
if (!task || task.userId !== keyRecord.userId) throw new AuthError('TASK_NOT_FOUND', '任务不存在', 404)
|
|
send(response, 200, { task: publicTask(task) })
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/health') {
|
|
send(response, 200, {
|
|
status: 'ok',
|
|
service: 'moyi-control-plane',
|
|
capabilities: { verificationCode: false, passwordReset: false },
|
|
})
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/auth/register') {
|
|
enforceAuthRateLimit(request, 'register')
|
|
const body = await readJson(request)
|
|
const result = await auth.register({
|
|
invitationCode: stringValue(body.invitationCode),
|
|
account: stringValue(body.account),
|
|
password: stringValue(body.password),
|
|
...(body.displayName ? { displayName: stringValue(body.displayName) } : {}),
|
|
}, meta)
|
|
setSessionCookie(response, result.session)
|
|
send(response, 201, { user: result.user })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/auth/login') {
|
|
enforceAuthRateLimit(request, 'login')
|
|
const body = await readJson(request)
|
|
const result = await auth.login({
|
|
account: stringValue(body.account),
|
|
password: stringValue(body.password),
|
|
}, meta)
|
|
setSessionCookie(response, result.session)
|
|
send(response, 200, { user: result.user })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/auth/logout') {
|
|
await auth.revoke(token, meta)
|
|
clearSessionCookie(response)
|
|
send(response, 204, undefined)
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/auth/me') {
|
|
const user = await auth.requireUser(token)
|
|
send(response, 200, { user })
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/models') {
|
|
await auth.requireUser(token)
|
|
send(response, 200, {
|
|
providers: await catalog.listProviders(),
|
|
models: await catalog.listModels(),
|
|
})
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/overview') {
|
|
const user = await auth.requireUser(token)
|
|
send(response, 200, buildOverview(user.id))
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/projects') {
|
|
const user = await auth.requireUser(token)
|
|
send(response, 200, { projects: await catalog.listProjects(user.id) })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/projects') {
|
|
const user = await auth.requireUser(token)
|
|
const body = await readJson(request)
|
|
const project = await catalog.createProject(user.id, {
|
|
name: stringValue(body.name),
|
|
...(body.description ? { description: stringValue(body.description) } : {}),
|
|
})
|
|
send(response, 201, { project })
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/keys') {
|
|
const user = await auth.requireUser(token)
|
|
send(response, 200, { keys: await catalog.listApiKeys(user.id) })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/keys') {
|
|
const user = await auth.requireUser(token)
|
|
const body = await readJson(request)
|
|
const result = await catalog.createApiKey(user.id, {
|
|
...(body.name ? { name: stringValue(body.name) } : {}),
|
|
...(body.projectId ? { projectId: stringValue(body.projectId) } : {}),
|
|
...(body.scopes !== undefined ? { scopes: stringArrayValue(body.scopes) } : {}),
|
|
...(body.modelIds !== undefined ? { modelIds: stringArrayValue(body.modelIds) } : {}),
|
|
})
|
|
send(response, 201, result)
|
|
return
|
|
}
|
|
|
|
const keyModelsMatch = path.match(/^\/api\/keys\/([^/]+)\/models$/)
|
|
const keyModelsId = keyModelsMatch?.[1]
|
|
if (method === 'POST' && keyModelsId) {
|
|
const user = await auth.requireUser(token)
|
|
const body = await readJson(request)
|
|
const apiKey = await catalog.updateApiKeyModels(user.id, keyModelsId, stringArrayValue(body.modelIds))
|
|
send(response, 200, { apiKey })
|
|
return
|
|
}
|
|
|
|
const keyRevokeMatch = path.match(/^\/api\/keys\/([^/]+)\/revoke$/)
|
|
const keyId = keyRevokeMatch?.[1]
|
|
if (method === 'POST' && keyId) {
|
|
const user = await auth.requireUser(token)
|
|
await catalog.revokeApiKey(user.id, keyId)
|
|
send(response, 204, undefined)
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/admin/users') {
|
|
send(response, 200, { users: await auth.listUsers(token) })
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/admin/invitations') {
|
|
send(response, 200, { invitations: await auth.listInvitations(token) })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/admin/invitations') {
|
|
const body = await readJson(request)
|
|
const result = await auth.createInvitation(token, {
|
|
...(body.label ? { label: stringValue(body.label) } : {}),
|
|
...(body.maxUses !== undefined ? { maxUses: Number(body.maxUses) } : {}),
|
|
...(body.expiresAt ? { expiresAt: stringValue(body.expiresAt) } : {}),
|
|
}, meta)
|
|
send(response, 201, result)
|
|
return
|
|
}
|
|
|
|
const invitationMatch = path.match(/^\/api\/admin\/invitations\/([^/]+)\/revoke$/)
|
|
const invitationId = invitationMatch?.[1]
|
|
if (method === 'POST' && invitationId) {
|
|
await auth.revokeInvitation(token, invitationId, meta)
|
|
send(response, 204, undefined)
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/admin/audit') {
|
|
send(response, 200, { events: await auth.listAudit(token, Number(parsed.query.limit || 100)) })
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/admin/providers') {
|
|
await auth.requireAdmin(token)
|
|
send(response, 200, { providers: await catalog.listProviders(true) })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/admin/providers') {
|
|
await auth.requireAdmin(token)
|
|
const body = await readJson(request)
|
|
const result = await catalog.createProvider({
|
|
code: stringValue(body.code),
|
|
name: stringValue(body.name),
|
|
protocol: providerProtocol(body.protocol),
|
|
sourceType: providerSourceType(body.sourceType),
|
|
...(body.baseUrl ? { baseUrl: stringValue(body.baseUrl) } : {}),
|
|
...(body.description ? { description: stringValue(body.description) } : {}),
|
|
...(body.credentialType ? { credentialType: credentialType(body.credentialType) } : {}),
|
|
...(body.credentialSecret ? { credentialSecret: stringValue(body.credentialSecret) } : {}),
|
|
})
|
|
send(response, 201, { provider: result })
|
|
return
|
|
}
|
|
|
|
if (method === 'GET' && path === '/api/admin/models') {
|
|
await auth.requireAdmin(token)
|
|
send(response, 200, { models: await catalog.listModels(true) })
|
|
return
|
|
}
|
|
|
|
if (method === 'POST' && path === '/api/admin/models') {
|
|
await auth.requireAdmin(token)
|
|
const body = await readJson(request)
|
|
const result = await catalog.createModel({
|
|
providerId: stringValue(body.providerId),
|
|
...(body.modelKey ? { modelKey: stringValue(body.modelKey) } : {}),
|
|
...(body.sourceLabel ? { sourceLabel: stringValue(body.sourceLabel) } : {}),
|
|
publicName: stringValue(body.publicName),
|
|
upstreamModel: stringValue(body.upstreamModel),
|
|
type: modelType(body.type),
|
|
mode: callMode(body.mode),
|
|
...(body.description ? { description: stringValue(body.description) } : {}),
|
|
...(body.inputTypes !== undefined ? { inputTypes: stringArrayValue(body.inputTypes) } : {}),
|
|
...(body.outputTypes !== undefined ? { outputTypes: stringArrayValue(body.outputTypes) } : {}),
|
|
...(body.pricing && typeof body.pricing === 'object' && !Array.isArray(body.pricing) ? { pricing: (() => { const pricing = body.pricing as Record<string, unknown>; return { ...(pricing.input !== undefined ? { input: numberValue(pricing.input, 'pricing.input') } : {}), ...(pricing.output !== undefined ? { output: numberValue(pricing.output, 'pricing.output') } : {}), ...(pricing.unit ? { unit: stringValue(pricing.unit) } : {}) } })() } : {}),
|
|
...(body.priority !== undefined ? { priority: numberValue(body.priority, 'priority') } : {}),
|
|
...(body.maxConcurrency !== undefined ? { maxConcurrency: numberValue(body.maxConcurrency, 'maxConcurrency') } : {}),
|
|
...(body.capabilities && typeof body.capabilities === 'object' && !Array.isArray(body.capabilities)
|
|
? { capabilities: body.capabilities as Record<string, unknown> }
|
|
: {}),
|
|
})
|
|
send(response, 201, { model: result })
|
|
return
|
|
}
|
|
|
|
send(response, 404, { error: { code: 'NOT_FOUND', message: '接口不存在' } })
|
|
}
|
|
|
|
async function readJson(request: IncomingMessage): Promise<Record<string, unknown>> {
|
|
let body = ''
|
|
for await (const chunk of request) {
|
|
body += chunk.toString()
|
|
if (body.length > 1_000_000) throw new AuthError('PAYLOAD_TOO_LARGE', '请求体过大', 413)
|
|
}
|
|
if (!body) return {}
|
|
try {
|
|
const value: unknown = JSON.parse(body)
|
|
if (!value || typeof value !== 'object' || Array.isArray(value)) throw new Error('not object')
|
|
return value as Record<string, unknown>
|
|
} catch {
|
|
throw new AuthError('INVALID_JSON', '请求体必须是有效 JSON')
|
|
}
|
|
}
|
|
|
|
function stringValue(value: unknown) {
|
|
return typeof value === 'string' ? value : ''
|
|
}
|
|
|
|
function numberValue(value: unknown, field: string) {
|
|
if (typeof value !== 'number' || !Number.isFinite(value)) throw new AuthError('INVALID_NUMBER', `${field} 必须是有效数字`)
|
|
return value
|
|
}
|
|
|
|
function booleanValue(value: unknown, field: string) {
|
|
if (typeof value !== 'boolean') throw new AuthError('INVALID_BOOLEAN', `${field} 必须是布尔值`)
|
|
return value
|
|
}
|
|
|
|
async function authenticatePlatformKey(request: IncomingMessage) {
|
|
const authorization = request.headers.authorization || ''
|
|
const match = authorization.match(/^Bearer\s+(.+)$/i)
|
|
const record = await catalog.authenticateApiKey(match?.[1] || '')
|
|
if (!record) throw new AuthError('INVALID_API_KEY', 'MOYI API Key 无效或已停用', 401)
|
|
return record
|
|
}
|
|
|
|
async function catalogModel(id: string) {
|
|
const model = (await catalog.listModels()).find((item) => item.id === id)
|
|
if (!model) throw new AuthError('MODEL_NOT_FOUND', '模型不存在或已下线', 404)
|
|
return model
|
|
}
|
|
|
|
function extractPrompt(messages: unknown) {
|
|
if (!Array.isArray(messages)) return ''
|
|
const last = [...messages].reverse().find((message) => message && typeof message === 'object' && 'content' in message) as { content?: unknown } | undefined
|
|
return typeof last?.content === 'string' ? last.content : ''
|
|
}
|
|
|
|
function randomToken(length: number) {
|
|
return Buffer.from(randomBytes(Math.ceil(length * 0.75))).toString('base64url').slice(0, length)
|
|
}
|
|
|
|
function recordTaskUsage(userId: string, model: string, taskId: string, status: UsageEvent['status']) {
|
|
const now = new Date().toISOString()
|
|
usageEvents.push({
|
|
id: `usage_${randomToken(14)}`,
|
|
userId,
|
|
kind: 'task',
|
|
model,
|
|
status,
|
|
taskId,
|
|
createdAt: now,
|
|
updatedAt: now,
|
|
})
|
|
}
|
|
|
|
function updateTaskUsage(taskId: string, status: UsageEvent['status'], updatedAt = new Date().toISOString()) {
|
|
const event = usageEvents.find((item) => item.taskId === taskId)
|
|
if (!event) return
|
|
event.status = status
|
|
event.updatedAt = updatedAt
|
|
}
|
|
|
|
function buildOverview(userId: string) {
|
|
const now = new Date()
|
|
const startOfToday = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), now.getUTCDate()))
|
|
const startOfMonth = new Date(Date.UTC(now.getUTCFullYear(), now.getUTCMonth(), 1))
|
|
const events = usageEvents.filter((event) => event.userId === userId)
|
|
const calls = events.filter((event) => event.kind === 'call')
|
|
const tasks = events.filter((event) => event.kind === 'task')
|
|
const latencySamples = calls.flatMap((event) => event.latencyMs === undefined ? [] : [event.latencyMs])
|
|
const completedTasks = tasks.filter((event) => event.status === 'succeeded' || event.status === 'failed')
|
|
const series = Array.from({ length: 7 }, (_, index) => {
|
|
const date = new Date(startOfToday)
|
|
date.setUTCDate(date.getUTCDate() - (6 - index))
|
|
const nextDate = new Date(date)
|
|
nextDate.setUTCDate(nextDate.getUTCDate() + 1)
|
|
return {
|
|
date: date.toISOString().slice(0, 10),
|
|
count: events.filter((event) => {
|
|
const createdAt = new Date(event.createdAt)
|
|
return createdAt >= date && createdAt < nextDate
|
|
}).length,
|
|
}
|
|
})
|
|
|
|
return {
|
|
generatedAt: now.toISOString(),
|
|
callsToday: calls.filter((event) => new Date(event.createdAt) >= startOfToday).length,
|
|
callsThisMonth: calls.filter((event) => new Date(event.createdAt) >= startOfMonth).length,
|
|
...(latencySamples.length
|
|
? { averageLatencyMs: Math.round(latencySamples.reduce((total, value) => total + value, 0) / latencySamples.length) }
|
|
: {}),
|
|
asyncTasks: tasks.length,
|
|
...(completedTasks.length
|
|
? { asyncSuccessRate: completedTasks.filter((event) => event.status === 'succeeded').length / completedTasks.length * 100 }
|
|
: {}),
|
|
tasks: {
|
|
queued: tasks.filter((event) => event.status === 'queued').length,
|
|
running: tasks.filter((event) => event.status === 'running').length,
|
|
succeeded: tasks.filter((event) => event.status === 'succeeded').length,
|
|
failed: tasks.filter((event) => event.status === 'failed').length,
|
|
},
|
|
series,
|
|
ledger: [],
|
|
}
|
|
}
|
|
|
|
function publicTask(task: MockTask) {
|
|
return {
|
|
id: task.id,
|
|
object: '3d.task',
|
|
model: task.model,
|
|
status: task.status,
|
|
created_at: task.createdAt,
|
|
updated_at: task.updatedAt,
|
|
...(task.result ? { result: task.result } : {}),
|
|
}
|
|
}
|
|
|
|
function stringArrayValue(value: unknown) {
|
|
if (!Array.isArray(value)) throw new AuthError('INVALID_ARRAY', '字段必须是字符串数组')
|
|
return value.filter((item): item is string => typeof item === 'string')
|
|
}
|
|
|
|
function providerProtocol(value: unknown): ProviderProtocol {
|
|
if (value === 'openai-compatible' || value === 'http' || value === 'sdk') return value
|
|
throw new AuthError('INVALID_PROVIDER_PROTOCOL', '供应商协议类型无效')
|
|
}
|
|
|
|
function providerSourceType(value: unknown): ProviderSourceType {
|
|
if (value === 'official' || value === 'relay' || value === 'self-hosted' || value === 'custom') return value
|
|
return 'custom'
|
|
}
|
|
|
|
function credentialType(value: unknown): 'none' | 'api-key' | 'bearer' | 'access-token' {
|
|
if (value === 'api-key' || value === 'bearer' || value === 'access-token') return value
|
|
return 'none'
|
|
}
|
|
|
|
function modelType(value: unknown): ModelType {
|
|
const types: ModelType[] = ['text', 'code', 'multimodal', 'image', 'audio', 'video', 'embedding', '3d']
|
|
if (typeof value === 'string' && types.includes(value as ModelType)) return value as ModelType
|
|
throw new AuthError('INVALID_MODEL_TYPE', '模型类型无效')
|
|
}
|
|
|
|
function callMode(value: unknown): CallMode {
|
|
if (value === 'sync' || value === 'stream' || value === 'async') return value
|
|
throw new AuthError('INVALID_CALL_MODE', '调用模式无效')
|
|
}
|
|
|
|
function enforceAuthRateLimit(request: IncomingMessage, action: string) {
|
|
const now = Date.now()
|
|
const key = `${action}:${request.socket.remoteAddress || 'unknown'}`
|
|
const current = authAttempts.get(key)
|
|
if (!current || current.resetAt <= now) {
|
|
authAttempts.set(key, { count: 1, resetAt: now + 15 * 60 * 1000 })
|
|
return
|
|
}
|
|
current.count += 1
|
|
if (current.count > 20) throw new AuthError('TOO_MANY_ATTEMPTS', '尝试次数过多,请稍后重试', 429)
|
|
}
|
|
|
|
function readCookie(header: string | undefined, name: string) {
|
|
const pair = header?.split(';').map((part) => part.trim()).find((part) => part.startsWith(`${name}=`))
|
|
return pair ? decodeURIComponent(pair.slice(name.length + 1)) : undefined
|
|
}
|
|
|
|
function setSessionCookie(response: ServerResponse, token: string) {
|
|
const secure = config.nodeEnv === 'production' ? '; Secure' : ''
|
|
response.setHeader('Set-Cookie', `moyi_session=${encodeURIComponent(token)}; HttpOnly; Path=/; SameSite=Lax; Max-Age=${config.sessionTtlHours * 60 * 60}${secure}`)
|
|
}
|
|
|
|
function clearSessionCookie(response: ServerResponse) {
|
|
response.setHeader('Set-Cookie', 'moyi_session=; HttpOnly; Path=/; SameSite=Lax; Max-Age=0')
|
|
}
|
|
|
|
function send(response: ServerResponse, statusCode: number, payload: unknown) {
|
|
response.statusCode = statusCode
|
|
if (statusCode === 204) {
|
|
response.end()
|
|
return
|
|
}
|
|
response.setHeader('Content-Type', 'application/json; charset=utf-8')
|
|
response.end(JSON.stringify(payload))
|
|
}
|
|
|
|
function handleError(response: ServerResponse, error: unknown) {
|
|
if (error instanceof AuthError) {
|
|
send(response, error.statusCode, { error: { code: error.code, message: error.message } })
|
|
return
|
|
}
|
|
if (error instanceof TripoProviderError) {
|
|
console.error(`Tripo provider error: ${error.message}`)
|
|
send(response, 502, { error: { code: 'TRIPO_PROVIDER_ERROR', message: '3D 模型供应商请求失败,请稍后重试' } })
|
|
return
|
|
}
|
|
if (error instanceof OpenAICompatibleProviderError) {
|
|
console.error(`OpenAI-compatible provider error: ${error.message}`)
|
|
send(response, 502, { error: { code: 'UPSTREAM_PROVIDER_ERROR', message: '上游模型供应商请求失败,请稍后重试' } })
|
|
return
|
|
}
|
|
if (error instanceof SeedanceProviderError) {
|
|
console.error(`Seedance provider error: ${error.message}`)
|
|
send(response, 502, { error: { code: 'SEEDANCE_PROVIDER_ERROR', message: 'Seedance 视频供应商请求失败,请稍后重试' } })
|
|
return
|
|
}
|
|
console.error(error)
|
|
send(response, 500, { error: { code: 'INTERNAL_ERROR', message: '服务暂时不可用' } })
|
|
}
|
|
|
|
async function close() {
|
|
if ('close' in repository && typeof repository.close === 'function') await repository.close()
|
|
server.close()
|
|
}
|
|
|
|
process.once('SIGINT', close)
|
|
process.once('SIGTERM', close)
|