most-box 0.1.0 → 0.1.2

package/server/src/http/errors.js

@@ -0,0 +1,35 @@
+export function getApiErrorStatus(err) {
+  switch (err.code) {
+    case 'VALIDATION_ERROR':
+    case 'PATH_SECURITY_ERROR':
+    case 'FILE_SIZE_ERROR':
+      return 400
+    case 'PEER_NOT_FOUND':
+      return 503
+    case 'INTEGRITY_ERROR':
+      return 422
+    case 'CONFLICT':
+      return 409
+    case 'PERMISSION_ERROR':
+      return 403
+    case 'ENGINE_NOT_INITIALIZED':
+      return 503
+    default:
+      return 500
+  }
+}
+
+export function errorJson(c, err) {
+  return c.json(
+    {
+      error: err.message,
+      code: err.code || 'UNKNOWN',
+    },
+    getApiErrorStatus(err)
+  )
+}
+
+export function badRequestOrAppError(c, err) {
+  if (err.code) return errorJson(c, err)
+  return c.json({ error: err.message }, 400)
+}

package/server/src/http/nodeLogs.js

@@ -0,0 +1,53 @@
+const NODE_LOG_FILTERS = {
+  join: ['join', 'joined', 'topic'],
+  pull: ['pull', 'p2p'],
+  verify: ['verify', 'verified', 'integrity', 'download:success'],
+  serve: ['seed', 'seeding', 'holding', 'publish:success', 'topic:joined'],
+  error: ['error', 'failed', 'fail'],
+}
+
+function getNodeLogSearchText(log = {}) {
+  let dataText = ''
+  try {
+    dataText = JSON.stringify(log.data || {})
+  } catch {}
+
+  return [log.level, log.event, log.message, dataText]
+    .map(value => String(value || '').toLowerCase())
+    .join(' ')
+}
+
+function matchesNodeLogFilter(log, filter) {
+  const normalized = String(filter || 'all')
+    .trim()
+    .toLowerCase()
+  if (!normalized || normalized === 'all') return true
+
+  const text = getNodeLogSearchText(log)
+  if (normalized === 'error') {
+    return (
+      log.level === 'error' ||
+      NODE_LOG_FILTERS.error.some(term => text.includes(term))
+    )
+  }
+
+  const terms = NODE_LOG_FILTERS[normalized] || [normalized]
+  return terms.some(term => text.includes(term))
+}
+
+export function listFilteredNodeLogs(nodeLogger, options = {}) {
+  const limit = Math.max(1, Math.min(Number(options.limit) || 100, 1000))
+  const filter = String(options.filter || 'all')
+    .trim()
+    .toLowerCase()
+  const query = String(options.query || '')
+    .trim()
+    .toLowerCase()
+  const logs = nodeLogger
+    .list(1000)
+    .filter(log => matchesNodeLogFilter(log, filter))
+    .filter(log => !query || getNodeLogSearchText(log).includes(query))
+    .slice(0, limit)
+
+  return { filter, query, logs }
+}

package/server/src/http/nodeStatus.js

@@ -0,0 +1,146 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { DEFAULT_NODE_HOST } from '../node/config.js'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const PACKAGE_JSON = readPackageJson()
+
+function readPackageJson() {
+  try {
+    return JSON.parse(
+      fs.readFileSync(
+        path.join(__dirname, '..', '..', '..', 'package.json'),
+        'utf-8'
+      )
+    )
+  } catch {
+    return { version: '0.0.0' }
+  }
+}
+
+export function getNetworkAddresses(appPort) {
+  return {
+    port: appPort,
+    addresses: [
+      { type: 'local', ip: 'localhost', label: '本机', iface: 'loopback' },
+    ],
+  }
+}
+
+export async function buildNodeStatus(engine, configStore, appPort) {
+  const config = configStore.getNodeConfig()
+  const { remoteInvites, ...publicConfig } = config
+  const remoteInviteCount = remoteInvites.length
+  const storage = await engine.getStorageStats()
+  const network = engine.getNetworkStatus()
+  const holdings = engine.listHoldings()
+
+  return {
+    status: 'online',
+    version: PACKAGE_JSON.version,
+    uptimeSeconds: Math.floor(process.uptime()),
+    nodeId: engine.getNodeId(),
+    host: DEFAULT_NODE_HOST,
+    port: appPort,
+    listen: getNetworkAddresses(appPort),
+    dataPath: configStore.getDataPath(),
+    config: {
+      ...publicConfig,
+      remoteInviteCount,
+      remoteInviteConfigured: remoteInviteCount > 0,
+    },
+    policy: {
+      maxFileSizeBytes: config.maxFileSizeBytes,
+    },
+    capacity: {
+      configuredBytes: config.capacityBytes,
+      usedBytes: storage.used,
+      freeBytes: Math.max(0, config.capacityBytes - storage.used),
+    },
+    storage,
+    network,
+    holdings,
+  }
+}
+
+export function buildOpenApiSpec(appPort) {
+  return {
+    openapi: '3.1.0',
+    info: {
+      title: 'MostBox Node Daemon API',
+      version: PACKAGE_JSON.version,
+    },
+    servers: [{ url: `http://localhost:${appPort}` }],
+    paths: {
+      '/api/node/status': {
+        get: {
+          summary: 'Get node daemon status',
+          responses: { 200: { description: 'Node status' } },
+        },
+      },
+      '/api/node/config': {
+        get: {
+          summary: 'Get node daemon config',
+          responses: { 200: { description: 'Node config' } },
+        },
+        post: {
+          summary: 'Update node daemon config',
+          responses: { 200: { description: 'Updated config' } },
+        },
+      },
+      '/api/node/policy': {
+        get: {
+          summary: 'Get local storage limits',
+          responses: { 200: { description: 'Storage limits' } },
+        },
+        post: {
+          summary: 'Update local storage limits',
+          responses: { 200: { description: 'Updated policy' } },
+        },
+      },
+      '/api/node/policy/evaluate': {
+        post: {
+          summary: 'Evaluate a local file against storage limits',
+          responses: { 200: { description: 'Storage limit decision' } },
+        },
+      },
+      '/api/node/holdings': {
+        get: {
+          summary: 'List CID replicas held by this node',
+          responses: { 200: { description: 'Node holdings' } },
+        },
+        post: {
+          summary: 'Add a held CID replica record and join its topic',
+          responses: { 200: { description: 'Created holding' } },
+        },
+      },
+      '/api/node/logs': {
+        get: {
+          summary: 'Read recent node daemon logs',
+          responses: { 200: { description: 'Node logs' } },
+        },
+        delete: {
+          summary: 'Clear node daemon logs',
+          responses: { 200: { description: 'Logs cleared' } },
+        },
+      },
+      '/api/node/diagnostics': {
+        get: {
+          summary: 'Export node diagnostics snapshot',
+          responses: { 200: { description: 'Diagnostics snapshot' } },
+        },
+      },
+      '/api/p2p/pull': {
+        post: {
+          summary: 'Pull a full file replica by CID',
+          responses: { 200: { description: 'Pull task result' } },
+        },
+      },
+    },
+  }
+}
+
+export function getPackageVersion() {
+  return PACKAGE_JSON.version
+}

package/server/src/http/staticFiles.js

@@ -0,0 +1,84 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { serveStatic } from '@hono/node-server/serve-static'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+
+const MIME_TYPES = {
+  '.html': 'text/html; charset=utf-8',
+  '.js': 'application/javascript; charset=utf-8',
+  '.css': 'text/css; charset=utf-8',
+  '.json': 'application/json',
+  '.png': 'image/png',
+  '.jpg': 'image/jpeg',
+  '.jpeg': 'image/jpeg',
+  '.gif': 'image/gif',
+  '.webp': 'image/webp',
+  '.svg': 'image/svg+xml',
+  '.ico': 'image/x-icon',
+  '.mp4': 'video/mp4',
+  '.webm': 'video/webm',
+  '.ogg': 'video/ogg',
+  '.mp3': 'audio/mpeg',
+  '.wav': 'audio/wav',
+  '.flac': 'audio/flac',
+  '.aac': 'audio/aac',
+  '.m4a': 'audio/mp4',
+  '.opus': 'audio/opus',
+  '.woff2': 'font/woff2',
+  '.woff': 'font/woff',
+}
+
+export function getMimeType(fileName) {
+  const ext = path.extname(fileName).toLowerCase()
+  return MIME_TYPES[ext] || 'application/octet-stream'
+}
+
+export function registerStaticRoutes(app) {
+  const publicDir = path.join(__dirname, '..', '..', '..', 'out')
+
+  app.get('/static/*', serveStatic({ root: './out' }))
+  app.get('/_next/*', serveStatic({ root: './out' }))
+
+  app.all('/api/*', c => {
+    return c.json({ error: 'Not found' }, 404)
+  })
+
+  app.get('*', async c => {
+    const pathname = c.req.path
+    const filePath = path.join(publicDir, pathname)
+    const resolved = path.resolve(filePath)
+    const resolvedPublic = path.resolve(publicDir)
+
+    if (
+      !resolved.startsWith(resolvedPublic + path.sep) &&
+      resolved !== resolvedPublic
+    ) {
+      return c.json({ error: 'Not found' }, 404)
+    }
+
+    if (fs.existsSync(filePath)) {
+      const stat = fs.statSync(filePath)
+      if (stat.isFile()) {
+        c.header('Content-Type', getMimeType(filePath))
+        return c.body(fs.readFileSync(filePath))
+      }
+      if (stat.isDirectory()) {
+        const dirIndex = path.join(filePath, 'index.html')
+        if (fs.existsSync(dirIndex)) {
+          c.header('Content-Type', 'text/html; charset=utf-8')
+          return c.body(fs.readFileSync(dirIndex, 'utf-8'))
+        }
+      }
+    }
+
+    const indexPath = path.join(publicDir, 'index.html')
+    if (fs.existsSync(indexPath)) {
+      c.header('Content-Type', 'text/html; charset=utf-8')
+      return c.body(fs.readFileSync(indexPath, 'utf-8'))
+    }
+
+    return c.json({ error: 'Not found' }, 404)
+  })
+}

package/server/src/http/uploads.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs'
+import path from 'node:path'
+import os from 'node:os'
+import Busboy from 'busboy'
+import { MAX_FILE_SIZE } from '../config.js'
+
+export const UPLOAD_TMP_DIR = path.join(os.tmpdir(), 'most-box-uploads')
+
+function decodeFilenameFromHeader(headerStr) {
+  if (!headerStr) return null
+
+  const filenameStarMatch = headerStr.match(
+    /filename\*=(?:UTF-8''|utf-8'')([^;\r\n]+)/i
+  )
+  if (filenameStarMatch) {
+    return decodeURIComponent(filenameStarMatch[1])
+  }
+
+  const filenameMatch = headerStr.match(/filename="([^"]+)"/)
+  if (filenameMatch) {
+    const rawFilename = filenameMatch[1]
+    try {
+      const buf = Buffer.from(rawFilename, 'latin1')
+      const decoded = buf.toString('utf8')
+      if (decoded.includes('\ufffd')) {
+        return rawFilename
+      }
+      return decoded
+    } catch {
+      return rawFilename
+    }
+  }
+
+  const filenamePlainMatch = headerStr.match(/filename=([^;\r\n]+)/)
+  if (filenamePlainMatch) {
+    return filenamePlainMatch[1].trim()
+  }
+  return null
+}
+
+export async function parseMultipartBusboy(req, maxUploadSize = MAX_FILE_SIZE) {
+  return new Promise((resolve, reject) => {
+    if (!fs.existsSync(UPLOAD_TMP_DIR)) {
+      fs.mkdirSync(UPLOAD_TMP_DIR, { recursive: true })
+    }
+
+    const busboy = Busboy({
+      headers: req.headers,
+      limits: {
+        fileSize: maxUploadSize,
+        files: 1,
+        fields: 0,
+      },
+    })
+
+    const result = { filePath: null, filename: null }
+    let fileSize = 0
+    let writeStream = null
+    let tempPath = null
+
+    busboy.on('file', (name, stream, info) => {
+      result.filename = decodeFilenameFromHeader(`filename="${info.filename}"`)
+      tempPath = path.join(
+        UPLOAD_TMP_DIR,
+        `upload_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+      )
+      writeStream = fs.createWriteStream(tempPath)
+
+      stream.on('data', chunk => {
+        fileSize += chunk.length
+        if (fileSize > maxUploadSize) {
+          stream.destroy()
+          writeStream.destroy()
+          fs.unlink(tempPath, () => {})
+          reject(new Error('File too large'))
+          return
+        }
+      })
+
+      stream.on('error', () => {
+        if (tempPath) fs.unlink(tempPath, () => {})
+      })
+
+      stream.pipe(writeStream)
+
+      writeStream.on('finish', () => {
+        result.filePath = tempPath
+        resolve(result)
+      })
+
+      writeStream.on('error', err => {
+        if (tempPath) fs.unlink(tempPath, () => {})
+        reject(err)
+      })
+    })
+
+    busboy.on('error', err => {
+      if (tempPath) fs.unlink(tempPath, () => {})
+      reject(err)
+    })
+
+    busboy.on('close', () => {
+      if (!result.filename) {
+        resolve(null)
+      }
+    })
+
+    req.on('error', err => {
+      if (tempPath) fs.unlink(tempPath, () => {})
+      reject(err)
+    })
+    req.pipe(busboy)
+  })
+}