@allbluecn/admin-app 0.1.0

package/src/server/knowledge-public/github-sync.ts

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { prisma } from '@allbluecn/database'
+
+export interface GithubData {
+  stars: number
+  repoUpdatedAt: Date | null
+  latestVersion: string | null
+  versionDate: Date | null
+}
+
+const API = 'https://api.github.com'
+const HEADERS: HeadersInit = {
+  Accept: 'application/vnd.github+json',
+  'User-Agent': 'AllBlue-KnowledgeBase',
+  ...(process.env.GITHUB_TOKEN
+    ? { Authorization: `Bearer ${process.env.GITHUB_TOKEN}` }
+    : {}),
+}
+
+export async function fetchGithubData(
+  owner: string,
+  repo: string,
+): Promise<GithubData | null> {
+  const repoRes = await fetch(`${API}/repos/${owner}/${repo}`, { headers: HEADERS })
+  if (!repoRes.ok) return null
+  const repoJson: any = await repoRes.json()
+
+  let latestVersion: string | null = null
+  let versionDate: Date | null = null
+  try {
+    const relRes = await fetch(`${API}/repos/${owner}/${repo}/releases/latest`, { headers: HEADERS })
+    if (relRes.ok) {
+      const relJson: any = await relRes.json()
+      latestVersion = relJson.tag_name ?? null
+      versionDate = relJson.published_at ? new Date(relJson.published_at) : null
+    }
+  } catch {
+    // ignore
+  }
+
+  return {
+    stars: repoJson.stargazers_count ?? 0,
+    repoUpdatedAt: repoJson.updated_at ? new Date(repoJson.updated_at) : null,
+    latestVersion,
+    versionDate,
+  }
+}
+
+export async function syncBookmarkGithub(bookmarkId: string): Promise<boolean> {
+  const bm = await prisma.websiteBookmark.findUnique({
+    where: { id: bookmarkId },
+    select: { id: true, isGithub: true, githubOwner: true, githubRepo: true },
+  })
+  if (!bm?.isGithub || !bm.githubOwner || !bm.githubRepo) return false
+
+  const data = await fetchGithubData(bm.githubOwner, bm.githubRepo)
+  await prisma.websiteBookmark.update({
+    where: { id: bookmarkId },
+    data: data
+      ? {
+          githubStars: data.stars,
+          githubRepoUpdatedAt: data.repoUpdatedAt,
+          githubLatestVersion: data.latestVersion,
+          githubVersionDate: data.versionDate,
+          githubSyncedAt: new Date(),
+        }
+      : { githubSyncedAt: new Date() },
+  })
+  return data !== null
+}

package/src/server/license-issue.ts

@@ -0,0 +1,78 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { prisma } from '@allbluecn/database'
+import { getProService } from '@/server/pro-services'
+import { FeatureRegistry } from '@allbluecn/kernel'
+import { requireAdmin } from '@/server/auth-helpers'
+
+export const issueLicense = async (data: {
+  customerName: string
+  customerEmail: string
+  customerId: string
+  plan: string
+  seats: number
+  features: Record<string, boolean>
+  expiresAt: string | null
+}) => {
+  const session = await requireAdmin()
+
+  const unknownKeys = Object.keys(data.features).filter(
+    (k) => !(k in FeatureRegistry),
+  )
+  if (unknownKeys.length > 0) {
+    throw new Error(
+      `未注册的功能 key：${unknownKeys.join(', ')}（须先在 FeatureRegistry 注册）`,
+    )
+  }
+
+  const license = getProService('license')
+  if (!license?.issue) {
+    throw new Error(
+      '当前部署不支持 license 签发（需 Pro 签发环境 + LICENSE_SIGNING_PRIVATE_KEY）',
+    )
+  }
+
+  const expiresAt = data.expiresAt ? new Date(data.expiresAt) : null
+  const result = await license.issue({
+    customerName: data.customerName,
+    customerEmail: data.customerEmail,
+    customerId: data.customerId,
+    plan: data.plan,
+    seats: data.seats,
+    features: data.features,
+    expiresAt,
+  })
+
+  await prisma.licenseKey.create({
+    data: {
+      key: result.key,
+      signature: result.signature,
+      payload: result.payload as never,
+      customerId: data.customerId,
+      customerName: data.customerName,
+      customerEmail: data.customerEmail,
+      plan: result.payload.plan,
+      seats: data.seats,
+      features: data.features as never,
+      expiresAt,
+      issuedById: session.user!.id,
+    },
+  })
+
+  return { key: result.key }
+}

package/src/server/middlewares/request.ts

@@ -0,0 +1,26 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createMiddleware } from '@tanstack/react-start'
+
+export interface RequestContext {
+  request: Request
+}
+
+export const requestContextMiddleware = createMiddleware().server<RequestContext>(async ({ request, next }) => {
+  return next({ context: { request } })
+})

package/src/server/observability/debug-middleware.ts

@@ -0,0 +1,39 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createMiddleware } from '@tanstack/react-start'
+
+export const debugMiddleware = createMiddleware().server(async ({ next }: any) => {
+  const result = await next() as any
+
+  if (process.env.NODE_ENV === 'development') {
+    const response = result.response || result
+    if (response instanceof Response) {
+      const headers = new Headers(response.headers)
+      headers.set('X-Debug-Timestamp', new Date().toISOString())
+      headers.set('X-Debug-Node-Version', process.version)
+      headers.set('X-Debug-Uptime', process.uptime().toString())
+      return new Response(response.body, {
+        status: response.status,
+        statusText: response.statusText,
+        headers,
+      })
+    }
+  }
+
+  return result
+})

package/src/server/observability/error-reporter.ts

@@ -0,0 +1,99 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { Prisma, prisma } from '@allbluecn/database'
+
+interface ErrorRecord {
+  name: string
+  message: string
+  stack?: string
+  context?: Record<string, unknown>
+}
+
+interface ErrorEntry {
+  count: number
+  lastSeen: Date
+  error: ErrorRecord
+}
+
+const errorStore = new Map<string, ErrorEntry>()
+let initialized = false
+
+export function reportError(error: Error, context?: Record<string, unknown>): void {
+  const key = `${error.name}:${error.message}`
+  const existing = errorStore.get(key)
+
+  if (existing) {
+    existing.count++
+    existing.lastSeen = new Date()
+  } else {
+    errorStore.set(key, {
+      count: 1,
+      lastSeen: new Date(),
+      error: { name: error.name, message: error.message, stack: error.stack, context },
+    })
+  }
+
+  const entry = errorStore.get(key)!
+  saveErrorReportAsync(key, entry).catch((e) => console.error('[ErrorReportSave]', e))
+}
+
+async function saveErrorReportAsync(key: string, entry: ErrorEntry): Promise<void> {
+  await prisma.monitoringErrorReport.upsert({
+    where: { id: key },
+    create: {
+      id: key,
+      errorName: entry.error.name,
+      errorMessage: entry.error.message,
+      stackTrace: entry.error.stack,
+      count: entry.count,
+      firstSeen: entry.lastSeen,
+      lastSeen: entry.lastSeen,
+      context: (entry.error.context as Prisma.InputJsonValue) ?? null,
+    },
+    update: {
+      count: entry.count,
+      lastSeen: entry.lastSeen,
+    },
+  })
+}
+
+export function getErrorStore(): Array<{ key: string; entry: ErrorEntry }> {
+  return Array.from(errorStore.entries()).map(([key, entry]) => ({ key, entry }))
+}
+
+export function resetErrors(): void {
+  errorStore.clear()
+}
+
+export function initErrorCollector(): void {
+  if (initialized) return
+  initialized = true
+
+  process.on('unhandledRejection', (reason: unknown) => {
+    const error = reason instanceof Error
+      ? reason
+      : new Error(`Unhandled rejection: ${String(reason)}`)
+    reportError(error, { source: 'unhandledRejection' })
+  })
+
+  process.on('uncaughtException', (error, origin) => {
+    reportError(error, { source: 'uncaughtException', origin })
+    console.error('[FATAL]', error.message || 'Uncaught exception')
+    process.exit(1)
+  })
+}

package/src/server/observability/health-check.ts

@@ -0,0 +1,140 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import os from 'node:os'
+import { prisma } from '@allbluecn/database'
+
+interface HealthResult {
+  status: 'healthy' | 'unhealthy'
+  checks: {
+    uptime: number
+    memory: NodeJS.MemoryUsage
+    database: { status: 'connected' | 'error'; latency?: number; error?: string }
+    cpu: { usage: number; cores: number; model: string }
+    disk: { total: number; free: number; usedPct: number }
+    load: { one: number; five: number; fifteen: number }
+    system: { platform: string; type: string; release: string; nodeVersion: string }
+  }
+}
+
+let healthTimer: ReturnType<typeof setInterval> | null = null
+let healthEnabled = true
+
+export async function performHealthCheck(): Promise<HealthResult> {
+  let dbResult: { status: 'connected' | 'error'; latency?: number; error?: string }
+
+  try {
+    const dbStart = Date.now()
+    await prisma.$queryRaw`SELECT 1`
+    const dbLatency = Date.now() - dbStart
+    dbResult = { status: 'connected', latency: dbLatency }
+  } catch (e) {
+    dbResult = { status: 'error', error: (e as Error).message }
+  }
+
+  const status: HealthResult['status'] = dbResult.status === 'error' ? 'unhealthy' : 'healthy'
+  const memory = process.memoryUsage()
+  const cpus = os.cpus()
+  const cpuCount = cpus.length
+  const cpuModel = cpus[0]?.model || 'unknown'
+  const loadavg = os.loadavg()
+  const totalMem = os.totalmem()
+  const freeMem = os.freemem()
+  const usedPct = ((totalMem - freeMem) / totalMem) * 100
+
+  const snapshot = {
+    status,
+    uptimeSeconds: process.uptime(),
+    memoryUsage: {
+      rss: memory.rss,
+      heapTotal: memory.heapTotal,
+      heapUsed: memory.heapUsed,
+      external: memory.external,
+      arrayBuffers: memory.arrayBuffers,
+    },
+    dbStatus: dbResult.status,
+    dbLatencyMs: dbResult.latency || null,
+  }
+
+  await prisma.monitoringHealthSnapshot.create({ data: snapshot })
+
+  return {
+    status,
+    checks: {
+      uptime: process.uptime(),
+      memory,
+      database: dbResult,
+      cpu: { usage: usedPct, cores: cpuCount, model: cpuModel },
+      disk: { total: totalMem, free: freeMem, usedPct },
+      load: { one: loadavg[0], five: loadavg[1], fifteen: loadavg[2] },
+      system: {
+        platform: os.platform(),
+        type: os.type(),
+        release: os.release(),
+        nodeVersion: process.version,
+      },
+    },
+  }
+}
+
+export function startHealthCheckTimer(intervalMs = 30_000): void {
+  if (healthTimer) clearInterval(healthTimer)
+  performHealthCheck().catch((e) => console.error('[HealthCheck]', e))
+  healthTimer = setInterval(() => {
+    performHealthCheck().catch((e) => console.error('[HealthCheck]', e))
+  }, intervalMs)
+  healthEnabled = true
+}
+
+export function stopHealthCheckTimer(): void {
+  if (healthTimer) {
+    clearInterval(healthTimer)
+    healthTimer = null
+  }
+  healthEnabled = false
+}
+
+export function isHealthCheckEnabled(): boolean {
+  return healthEnabled
+}
+
+export async function setHealthCheckEnabled(enabled: boolean): Promise<void> {
+  if (enabled) {
+    startHealthCheckTimer()
+  } else {
+    stopHealthCheckTimer()
+  }
+
+  await prisma.systemSetting.upsert({
+    where: { key: 'monitoring_health_check_enabled' },
+    create: {
+      key: 'monitoring_health_check_enabled',
+      value: enabled ? 'true' : 'false',
+      category: 'monitoring',
+      desc: '监控健康检查自动定时开关',
+    },
+    update: { value: enabled ? 'true' : 'false' },
+  })
+}
+
+export async function getHealthCheckEnabled(): Promise<boolean> {
+  const setting = await prisma.systemSetting.findUnique({
+    where: { key: 'monitoring_health_check_enabled' },
+  })
+  if (!setting) return true
+  return setting.value === 'true'
+}

package/src/server/observability/index.ts

@@ -0,0 +1,33 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+export { logger } from './logger'
+export { metrics } from './metrics'
+export { reportError, getErrorStore, resetErrors, initErrorCollector } from './error-reporter'
+export {
+  performHealthCheck,
+  startHealthCheckTimer,
+  stopHealthCheckTimer,
+  isHealthCheckEnabled,
+  setHealthCheckEnabled,
+  getHealthCheckEnabled,
+} from './health-check'
+export { observabilityMiddleware, requestLogStore } from './request-middleware'
+export { debugMiddleware } from './debug-middleware'
+export { timed } from './timing'
+export type { LogLevel } from './logger'
+export type { TimingResult } from './timing'

package/src/server/observability/logger.ts

@@ -0,0 +1,49 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { createIsomorphicFn } from '@tanstack/react-start'
+
+export type LogLevel = 'debug' | 'info' | 'warn' | 'error'
+
+type LogData = Record<string, unknown>
+
+const logger = createIsomorphicFn()
+  .server((level: LogLevel, message: string, data?: LogData) => {
+    const timestamp = new Date().toISOString()
+
+    if (process.env.NODE_ENV === 'development') {
+      (console as any)[level](`[${timestamp}] [${level.toUpperCase()}]`, message, data)
+    } else {
+      console.log(
+        JSON.stringify({
+          timestamp,
+          level,
+          message,
+          data,
+          service: 'allblue-admin',
+          environment: process.env.NODE_ENV,
+        }),
+      )
+    }
+  })
+  .client((level: LogLevel, message: string, data?: LogData) => {
+    if (process.env.NODE_ENV === 'development') {
+      (console as any)[level](`[CLIENT] [${level.toUpperCase()}]`, message, data)
+    }
+  })
+
+export { logger }

package/src/server/observability/metrics.ts

@@ -0,0 +1,105 @@
+// SPDX-License-Identifier: AGPL-3.0-or-later
+// AllBlue - 理想之海
+// Copyright (C) 2026 AllBlue Contributors
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import { prisma } from '@allbluecn/database'
+
+interface MetricStats {
+  count: number
+  avg: number
+  p50: number
+  p95: number
+  p99: number
+  min: number
+  max: number
+}
+
+class MetricsCollector {
+  private metrics = new Map<string, number[]>()
+  private readonly MAX_SAMPLES = 1000
+  private flushTimer?: ReturnType<typeof setInterval>
+
+  constructor() {
+    this.flushTimer = setInterval(() => {
+      this.flushToDb().catch((e) => console.error('[MetricsFlush]', e))
+    }, 60_000)
+  }
+
+  recordTiming(name: string, duration: number): void {
+    if (!this.metrics.has(name)) {
+      this.metrics.set(name, [])
+    }
+    const samples = this.metrics.get(name)!
+    samples.push(duration)
+    if (samples.length > this.MAX_SAMPLES) {
+      samples.shift()
+    }
+  }
+
+  getStats(name: string): MetricStats | null {
+    const timings = this.metrics.get(name)
+    if (!timings || timings.length === 0) return null
+
+    const sorted = [...timings].sort((a, b) => a - b)
+    const sum = sorted.reduce((a, b) => a + b, 0)
+    return {
+      count: sorted.length,
+      avg: Math.round(sum / sorted.length * 100) / 100,
+      p50: sorted[Math.floor(sorted.length * 0.5)],
+      p95: sorted[Math.floor(sorted.length * 0.95)],
+      p99: sorted[Math.floor(sorted.length * 0.99)],
+      min: sorted[0],
+      max: sorted[sorted.length - 1],
+    }
+  }
+
+  getAllStats(): Record<string, MetricStats> {
+    const stats: Record<string, MetricStats> = {}
+    for (const [name, timings] of this.metrics) {
+      const s = this.getStats(name)
+      if (s) stats[name] = s
+    }
+    return stats
+  }
+
+  async flushToDb(): Promise<void> {
+    const allStats = this.getAllStats()
+    for (const [name, stats] of Object.entries(allStats)) {
+      await prisma.monitoringMetricsSnapshot.create({
+        data: {
+          metricName: name,
+          count: stats.count,
+          avg: stats.avg,
+          p50: stats.p50,
+          p95: stats.p95,
+          p99: stats.p99,
+          min: stats.min,
+          max: stats.max,
+        },
+      })
+    }
+  }
+
+  reset(): void {
+    this.metrics.clear()
+  }
+
+  destroy(): void {
+    if (this.flushTimer) clearInterval(this.flushTimer)
+  }
+}
+
+export const metrics = new MetricsCollector()