most-box 0.1.0 → 0.1.1

package/server/index.js

@@ -13,53 +13,238 @@ import { MostBoxEngine } from './src/index.js'
 import { parseMostLink, validateCidString } from './src/core/cid.js'
 import { sanitizeFilename } from './src/utils/security.js'
 import { MAX_FILE_SIZE } from './src/config.js'
+import {
+  createNodeConfigStore,
+  evaluateStorageLimits,
+} from './src/node/config.js'
+import { createNodeLogger } from './src/node/logs.js'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const PORT = Number(process.env.MOSTBOX_PORT || process.env.PORT) || 1976
 const HOST = process.env.MOSTBOX_HOST || '0.0.0.0'
 
-const MAX_UPLOAD_SIZE = MAX_FILE_SIZE
 const UPLOAD_TMP_DIR = path.join(os.tmpdir(), 'most-box-uploads')
 
 const RATE_LIMIT_WINDOW = 60 * 1000
 const RATE_LIMIT_MAX_REQUESTS = 120
 
 // --- 配置 ---
-const CONFIG_DIR = path.join(os.homedir(), '.most-box')
-const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json')
+const defaultConfigStore = createNodeConfigStore()
+const defaultNodeLogger = createNodeLogger(defaultConfigStore.configDir)
+const CONFIG_DIR = defaultConfigStore.configDir
+const PACKAGE_JSON = readPackageJson()
+
+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
+  }
+}
+
+function errorJson(c, err) {
+  return c.json(
+    {
+      error: err.message,
+      code: err.code || 'UNKNOWN',
+    },
+    getApiErrorStatus(err)
+  )
+}
 
-function loadConfig() {
+function readPackageJson() {
   try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf-8'))
-    }
-  } catch (err) {
-    console.error('[Config] Load error:', err.message)
+    return JSON.parse(
+      fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf-8')
+    )
+  } catch {
+    return { version: '0.0.0' }
   }
-  return {}
 }
 
-function saveConfig(config) {
-  try {
-    if (!fs.existsSync(CONFIG_DIR)) {
-      fs.mkdirSync(CONFIG_DIR, { recursive: true })
+function getDataPath(configStore = defaultConfigStore) {
+  return configStore.getDataPath()
+}
+
+function resolveDataPathForSave(inputPath) {
+  let dataPath = String(inputPath || '').trim()
+  let basePath = dataPath
+
+  if (!dataPath) {
+    return { dataPath: '' }
+  }
+
+  if (dataPath.match(/^[A-Za-z]:\\$/)) {
+    basePath = dataPath
+    dataPath = path.join(dataPath, 'most-data')
+  }
+
+  if (!fs.existsSync(basePath)) {
+    return { error: '目录不存在' }
+  }
+
+  if (!fs.existsSync(dataPath)) {
+    fs.mkdirSync(dataPath, { recursive: true })
+  }
+
+  return { dataPath }
+}
+
+function getNetworkAddresses(appPort) {
+  const interfaces = os.networkInterfaces()
+  const addresses = []
+  const seen = new Set()
+
+  for (const [name, nets] of Object.entries(interfaces)) {
+    for (const net of nets) {
+      if (net.family !== 'IPv4' || net.internal) continue
+      if (seen.has(net.address)) continue
+      seen.add(net.address)
+
+      let type = 'lan'
+      let label = '局域网'
+      if (net.address.startsWith('100.')) {
+        type = 'tailscale'
+        label = 'Tailscale'
+      } else if (
+        name.toLowerCase().includes('zt') ||
+        name.toLowerCase().includes('zerotier')
+      ) {
+        type = 'zerotier'
+        label = 'ZeroTier'
+      }
+
+      addresses.push({ type, ip: net.address, label, iface: name })
     }
-    const tmpPath = CONFIG_FILE + '.tmp'
-    fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2), 'utf-8')
-    fs.renameSync(tmpPath, CONFIG_FILE)
-    return true
-  } catch (err) {
-    console.error('[Config] Save error:', err.message)
-    return false
   }
+
+  const localEntry = {
+    type: 'local',
+    ip: 'localhost',
+    label: '本机',
+    iface: 'loopback',
+  }
+  return { port: appPort, addresses: [localEntry, ...addresses] }
 }
 
-function getDataPath() {
-  if (process.env.MOSTBOX_DATA_PATH) {
-    return process.env.MOSTBOX_DATA_PATH
+async function buildNodeStatus(engine, configStore, appPort, host) {
+  const config = configStore.getNodeConfig()
+  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,
+    port: appPort,
+    listen: getNetworkAddresses(appPort),
+    dataPath: getDataPath(configStore),
+    config,
+    policy: {
+      maxFileSizeBytes: config.maxFileSizeBytes,
+    },
+    capacity: {
+      configuredBytes: config.capacityBytes,
+      usedBytes: storage.used,
+      freeBytes: Math.max(0, config.capacityBytes - storage.used),
+    },
+    storage,
+    network,
+    holdings,
+  }
+}
+
+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 storage limits' } },
+        },
+      },
+      '/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/storage': {
+        get: {
+          summary: 'Get storage statistics',
+          responses: { 200: { description: 'Storage statistics' } },
+        },
+      },
+      '/api/p2p/pull': {
+        post: {
+          summary: 'Pull a full file replica by CID',
+          responses: { 200: { description: 'Pull task result' } },
+        },
+      },
+    },
   }
-  const config = loadConfig()
-  return config.dataPath || path.join(os.homedir(), 'most-data')
 }
 
 // --- 静态文件服务 ---
@@ -125,7 +310,7 @@ function decodeFilenameFromHeader(headerStr) {
   return null
 }
 
-async function parseMultipartBusboy(req) {
+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 })
@@ -134,7 +319,7 @@ async function parseMultipartBusboy(req) {
     const busboy = Busboy({
       headers: req.headers,
       limits: {
-        fileSize: MAX_UPLOAD_SIZE,
+        fileSize: maxUploadSize,
         files: 1,
         fields: 0,
       },
@@ -155,7 +340,7 @@ async function parseMultipartBusboy(req) {
 
       stream.on('data', chunk => {
         fileSize += chunk.length
-        if (fileSize > MAX_UPLOAD_SIZE) {
+        if (fileSize > maxUploadSize) {
           stream.destroy()
           writeStream.destroy()
           fs.unlink(tempPath, () => {})
@@ -203,6 +388,10 @@ async function parseMultipartBusboy(req) {
 // --- Hono 应用工厂 ---
 export function createApp(engine, options = {}) {
   const appPort = options.port || PORT
+  const appHost = options.host || HOST
+  const configStore = options.configStore || defaultConfigStore
+  const nodeLogger =
+    options.nodeLogger || createNodeLogger(configStore.configDir || CONFIG_DIR)
   const wssRef = options.wssRef || { current: null }
   const serverInstanceRef = options.serverInstanceRef || { current: null }
 
@@ -231,7 +420,7 @@ export function createApp(engine, options = {}) {
     return async (c, next) => {
       const clientIp =
         c.req.header('x-forwarded-for') ||
-        c.env.incoming?.socket?.remoteAddress ||
+        c.env?.incoming?.socket?.remoteAddress ||
         'unknown'
       if (!checkRateLimit(clientIp)) {
         return c.json({ error: 'Too many requests' }, 429)
@@ -259,6 +448,33 @@ export function createApp(engine, options = {}) {
     }
   }
 
+  async function broadcastNodeStatus() {
+    try {
+      const status = await buildNodeStatus(
+        engine,
+        configStore,
+        appPort,
+        appHost
+      )
+      wsBroadcast('node:status', status)
+      return status
+    } catch (err) {
+      const entry = nodeLogger.append({
+        level: 'error',
+        event: 'node:status:error',
+        message: err.message,
+      })
+      wsBroadcast('node:log', entry)
+      return null
+    }
+  }
+
+  function appendNodeLog(input) {
+    const entry = nodeLogger.append(input)
+    wsBroadcast('node:log', entry)
+    return entry
+  }
+
   function wsSendToChannel(channelName, event, data) {
     const payload = JSON.stringify({ event, data })
     const subscribers = channelSubscriptions.get(channelName)
@@ -268,7 +484,10 @@ export function createApp(engine, options = {}) {
           try {
             ws.send(payload)
           } catch (err) {
-            console.warn('[WS] Failed to send to channel subscriber:', err.message)
+            console.warn(
+              '[WS] Failed to send to channel subscriber:',
+              err.message
+            )
           }
         }
       })
@@ -313,8 +532,10 @@ export function createApp(engine, options = {}) {
     cors({
       origin: [
         'http://localhost:3000',
+        'http://127.0.0.1:3000',
         'https://most.box',
         `http://localhost:${appPort}`,
+        `http://127.0.0.1:${appPort}`,
       ],
       credentials: true,
     })
@@ -327,9 +548,10 @@ export function createApp(engine, options = {}) {
   app.onError((err, c) => {
     console.error('[API Error]', err)
     try {
-      const errorLogPath = path.join(CONFIG_DIR, 'server-error.log')
-      if (!fs.existsSync(CONFIG_DIR)) {
-        fs.mkdirSync(CONFIG_DIR, { recursive: true })
+      const errorLogDir = configStore.configDir || CONFIG_DIR
+      const errorLogPath = path.join(errorLogDir, 'server-error.log')
+      if (!fs.existsSync(errorLogDir)) {
+        fs.mkdirSync(errorLogDir, { recursive: true })
       }
       fs.appendFileSync(
         errorLogPath,
@@ -345,45 +567,134 @@ export function createApp(engine, options = {}) {
   })
 
   app.get('/api/config', c => {
-    const config = loadConfig()
+    const config = configStore.loadRawConfig()
     return c.json({ dataPath: config.dataPath || '' })
   })
 
   app.post('/api/config', async c => {
     const body = await c.req.json()
-    const config = loadConfig()
+    const patch = {}
 
     if (body.resetStorage) {
-      config.dataPath = ''
+      patch.dataPath = ''
     } else if (body.dataPath !== undefined) {
-      let dataPath = body.dataPath.trim()
-      let basePath = dataPath
+      const resolved = resolveDataPathForSave(body.dataPath)
+      if (resolved.error) return c.json({ error: resolved.error }, 400)
+      patch.dataPath = resolved.dataPath
+    }
 
-      if (dataPath.match(/^[A-Za-z]:\\$/)) {
-        basePath = dataPath
-        dataPath = path.join(dataPath, 'most-data')
-      }
+    const { success } = configStore.saveNodeConfigPatch(patch)
+    appendNodeLog({
+      event: 'node:config:updated',
+      message: 'Node config updated',
+      data: { dataPath: getDataPath(configStore) },
+    })
+    await broadcastNodeStatus()
+    return c.json({ success, dataPath: getDataPath(configStore) })
+  })
 
-      if (!fs.existsSync(basePath)) {
-        return c.json({ error: '目录不存在' }, 400)
-      }
+  app.get('/api/config/data-path', c => {
+    const config = configStore.getNodeConfig()
+    const isDefault = !config.dataPath
+    const dataPath = getDataPath(configStore)
+    return c.json({ dataPath, isDefault })
+  })
 
-      if (!fs.existsSync(dataPath)) {
-        fs.mkdirSync(dataPath, { recursive: true })
-      }
+  app.get('/api/node/status', async c => {
+    try {
+      return c.json(
+        await buildNodeStatus(engine, configStore, appPort, appHost)
+      )
+    } catch (err) {
+      return errorJson(c, err)
+    }
+  })
 
-      config.dataPath = dataPath
+  app.get('/api/node/config', c => {
+    const config = configStore.getNodeConfig()
+    return c.json({
+      ...config,
+      dataPath: getDataPath(configStore),
+      configuredDataPath: config.dataPath,
+      isDefaultDataPath: !config.dataPath && !process.env.MOSTBOX_DATA_PATH,
+      envDataPath: process.env.MOSTBOX_DATA_PATH || null,
+    })
+  })
+
+  app.post('/api/node/config', async c => {
+    const body = await c.req.json()
+    const patch = { ...body }
+
+    if (body.resetStorage) {
+      patch.dataPath = ''
+    } else if (body.dataPath !== undefined) {
+      const resolved = resolveDataPathForSave(body.dataPath)
+      if (resolved.error) return c.json({ error: resolved.error }, 400)
+      patch.dataPath = resolved.dataPath
     }
 
-    const success = saveConfig(config)
-    return c.json({ success, dataPath: getDataPath() })
+    const { success, config } = configStore.saveNodeConfigPatch(patch)
+    engine.setMaxFileSize(config.maxFileSizeBytes)
+    appendNodeLog({
+      event: 'node:config:updated',
+      message: 'Node daemon config updated',
+      data: {
+        dataPath: getDataPath(configStore),
+        capacityBytes: config.capacityBytes,
+      },
+    })
+    await broadcastNodeStatus()
+    return c.json({ success, ...config, dataPath: getDataPath(configStore) })
   })
 
-  app.get('/api/config/data-path', c => {
-    const config = loadConfig()
-    const isDefault = !config.dataPath
-    const dataPath = getDataPath()
-    return c.json({ dataPath, isDefault })
+  app.get('/api/node/policy', c => {
+    const config = configStore.getNodeConfig()
+    return c.json({
+      maxFileSizeBytes: config.maxFileSizeBytes,
+    })
+  })
+
+  app.post('/api/node/policy', async c => {
+    const body = await c.req.json()
+    const { success, config } = configStore.saveNodeConfigPatch({
+      maxFileSizeBytes: body.maxFileSizeBytes,
+    })
+    engine.setMaxFileSize(config.maxFileSizeBytes)
+    const policy = {
+      maxFileSizeBytes: config.maxFileSizeBytes,
+    }
+    appendNodeLog({
+      event: 'node:policy:updated',
+      message: 'Node storage limits updated',
+      data: policy,
+    })
+    await broadcastNodeStatus()
+    return c.json({ success, ...policy })
+  })
+
+  app.post('/api/node/policy/evaluate', async c => {
+    const body = await c.req.json()
+    const decision = evaluateStorageLimits(configStore.getNodeConfig(), body)
+    return c.json(decision)
+  })
+
+  app.get('/api/node/logs', c => {
+    const limit = Number(c.req.query('limit') || 100)
+    return c.json({
+      logFile: nodeLogger.logFile,
+      logs: nodeLogger.list(limit),
+    })
+  })
+
+  app.delete('/api/node/logs', c => {
+    const success = nodeLogger.clear()
+    const clearedAt = new Date().toISOString()
+    wsBroadcast('node:logs:cleared', { clearedAt })
+    return c.json({ success, clearedAt })
+  })
+
+  app.get('/api/openapi.json', c => {
+    return c.json(buildOpenApiSpec(appPort))
   })
 
   // --- 网络路由 ---
@@ -392,40 +703,59 @@ export function createApp(engine, options = {}) {
   })
 
   app.get('/api/network', c => {
-    const interfaces = os.networkInterfaces()
-    const addresses = []
-    const seen = new Set()
-
-    for (const [name, nets] of Object.entries(interfaces)) {
-      for (const net of nets) {
-        if (net.family !== 'IPv4' || net.internal) continue
-        if (seen.has(net.address)) continue
-        seen.add(net.address)
-
-        let type = 'lan'
-        let label = '局域网'
-        if (net.address.startsWith('100.')) {
-          type = 'tailscale'
-          label = 'Tailscale'
-        } else if (
-          name.toLowerCase().includes('zt') ||
-          name.toLowerCase().includes('zerotier')
-        ) {
-          type = 'zerotier'
-          label = 'ZeroTier'
-        }
+    return c.json(getNetworkAddresses(appPort))
+  })
 
-        addresses.push({ type, ip: net.address, label, iface: name })
-      }
+  // --- 节点保种路由 ---
+  app.get('/api/node/holdings', c => {
+    try {
+      return c.json(engine.listHoldings())
+    } catch (err) {
+      return errorJson(c, err)
     }
+  })
 
-    const localEntry = {
-      type: 'local',
-      ip: 'localhost',
-      label: '本机',
-      iface: 'loopback',
+  app.post('/api/node/holdings', async c => {
+    try {
+      const body = await c.req.json()
+      const holding = await engine.addHolding(body)
+      appendNodeLog({
+        event: 'node:holding:added',
+        message: 'Node holding added',
+        data: { cid: holding.cid, size: holding.size },
+      })
+      await broadcastNodeStatus()
+      return c.json({ success: true, holding })
+    } catch (err) {
+      return errorJson(c, err)
+    }
+  })
+
+  app.post('/api/p2p/pull', async c => {
+    try {
+      const body = await c.req.json()
+      const timeout =
+        body.timeout === undefined ? undefined : Number(body.timeout)
+      const result = await engine.pullByCid({
+        ...body,
+        timeout: Number.isFinite(timeout) && timeout > 0 ? timeout : undefined,
+      })
+      appendNodeLog({
+        event: 'node:pull:success',
+        message: 'P2P pull completed',
+        data: { cid: result.cid, taskId: result.taskId },
+      })
+      await broadcastNodeStatus()
+      return c.json({ success: true, ...result })
+    } catch (err) {
+      appendNodeLog({
+        level: 'error',
+        event: 'node:pull:error',
+        message: err.message,
+        data: { code: err.code || 'UNKNOWN' },
+      })
+      return errorJson(c, err)
     }
-    return c.json({ port: appPort, addresses: [localEntry, ...addresses] })
   })
 
   // --- 文件路由 ---
@@ -435,7 +765,10 @@ export function createApp(engine, options = {}) {
 
   app.post('/api/publish', async c => {
     const req = c.env.incoming
-    const result = await parseMultipartBusboy(req)
+    const result = await parseMultipartBusboy(
+      req,
+      configStore.getNodeConfig().maxFileSizeBytes
+    )
 
     if (!result || !result.filename) {
       return c.json({ error: 'No file provided' }, 400)
@@ -444,7 +777,8 @@ export function createApp(engine, options = {}) {
     try {
       const publishResult = await engine.publishFile(
         result.filePath,
-        result.filename
+        result.filename,
+        { localPath: null }
       )
       return c.json({ success: true, ...publishResult })
     } finally {
@@ -452,14 +786,12 @@ export function createApp(engine, options = {}) {
     }
   })
 
-  app.post('/api/download', async c => {
+  app.post('/api/download/check', async c => {
     const body = await c.req.json()
     if (!body.link) {
       return c.json({ error: 'link is required' }, 400)
     }
 
-    const taskId = `dl_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
-
     const parsed = parseMostLink(body.link)
     if (parsed.error) {
       return c.json({ error: parsed.error }, 400)
@@ -469,15 +801,70 @@ export function createApp(engine, options = {}) {
       .getPublishedFiles()
       .find(f => f.cid === parsed.cid)
     if (existingFile) {
-      console.log(`[MostBox] File already exists: ${existingFile.fileName}`)
       return c.json({
         success: true,
-        taskId,
-        alreadyExists: true,
+        available: true,
+        cid: parsed.cid,
         fileName: existingFile.fileName,
+        size: Number(existingFile.size) || null,
+        alreadyExists: true,
       })
     }
 
+    if (engine.hasDownloadNameConflict(parsed.fileName)) {
+      return c.json(
+        {
+          error: `已有同名文件: ${parsed.fileName}`,
+          code: 'CONFLICT',
+        },
+        409
+      )
+    }
+
+    try {
+      const result = await engine.checkDownloadAvailability(body.link)
+      return c.json({ success: true, ...result })
+    } catch (err) {
+      return errorJson(c, err)
+    }
+  })
+
+  app.post('/api/download', async c => {
+    const body = await c.req.json()
+    if (!body.link) {
+      return c.json({ error: 'link is required' }, 400)
+    }
+
+    const taskId = `dl_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`
+
+    const parsed = parseMostLink(body.link)
+    if (parsed.error) {
+      return c.json({ error: parsed.error }, 400)
+    }
+
+    const existingFile = engine
+      .getPublishedFiles()
+      .find(f => f.cid === parsed.cid)
+    if (existingFile) {
+      console.log(`[MostBox] File already exists: ${existingFile.fileName}`)
+      try {
+        const result = await engine.downloadFile(body.link, taskId)
+        return c.json({ success: true, ...result })
+      } catch (err) {
+        return errorJson(c, err)
+      }
+    }
+
+    if (engine.hasDownloadNameConflict(parsed.fileName)) {
+      return c.json(
+        {
+          error: `已有同名文件: ${parsed.fileName}`,
+          code: 'CONFLICT',
+        },
+        409
+      )
+    }
+
     engine.downloadFile(body.link, taskId).catch(err => {
       if (err.message === 'Download cancelled') {
         wsBroadcast('download:cancelled', { taskId })
@@ -596,7 +983,7 @@ export function createApp(engine, options = {}) {
       return c.json({ error: cidValidation.error }, 400)
     }
     try {
-      const result = engine.restoreTrashFile(cid)
+      const result = await engine.restoreTrashFile(cid)
       return c.json({ success: true, files: result })
     } catch (err) {
       return c.json({ error: err.message }, 400)
@@ -795,7 +1182,10 @@ export function createApp(engine, options = {}) {
     const resolved = path.resolve(filePath)
     const resolvedPublic = path.resolve(publicDir)
 
-    if (!resolved.startsWith(resolvedPublic + path.sep) && resolved !== resolvedPublic) {
+    if (
+      !resolved.startsWith(resolvedPublic + path.sep) &&
+      resolved !== resolvedPublic
+    ) {
       return c.json({ error: 'Not found' }, 404)
     }
 
@@ -828,6 +1218,8 @@ export function createApp(engine, options = {}) {
     app,
     wsBroadcast,
     wsSendToChannel,
+    broadcastNodeStatus,
+    appendNodeLog,
     subscribeToChannel,
     unsubscribeFromChannel,
     cleanupWsSubscriptions,
@@ -852,10 +1244,15 @@ export async function main() {
     )
   }
 
-  const dataPath = getDataPath()
+  const configStore = defaultConfigStore
+  const nodeLogger = defaultNodeLogger
+  const dataPath = getDataPath(configStore)
   console.log(`[MostBox] Storage: ${dataPath}`)
 
-  const engine = new MostBoxEngine({ dataPath })
+  const engine = new MostBoxEngine({
+    dataPath,
+    maxFileSize: configStore.getNodeConfig().maxFileSizeBytes,
+  })
 
   const wssRef = { current: null }
   const serverInstanceRef = { current: null }
@@ -864,25 +1261,78 @@ export async function main() {
     app,
     wsBroadcast,
     wsSendToChannel,
+    broadcastNodeStatus,
+    appendNodeLog,
     subscribeToChannel,
     unsubscribeFromChannel,
     cleanupWsSubscriptions,
   } = createApp(engine, {
     port: PORT,
+    host: HOST,
+    configStore,
+    nodeLogger,
     wssRef,
     serverInstanceRef,
   })
 
+  let engineReadyForStatus = false
+  const safeBroadcastNodeStatus = () => {
+    if (engineReadyForStatus) {
+      broadcastNodeStatus()
+    }
+  }
+
   engine.on('download:progress', data => wsBroadcast('download:progress', data))
   engine.on('download:status', data => wsBroadcast('download:status', data))
-  engine.on('download:success', data => wsBroadcast('download:success', data))
+  engine.on('download:success', data => {
+    wsBroadcast('download:success', data)
+    appendNodeLog({
+      event: 'node:download:success',
+      message: 'Download verified and stored',
+      data,
+    })
+    safeBroadcastNodeStatus()
+  })
   engine.on('download:cancelled', data =>
     wsBroadcast('download:cancelled', data)
   )
   engine.on('publish:progress', data => wsBroadcast('publish:progress', data))
-  engine.on('publish:success', data => wsBroadcast('publish:success', data))
+  engine.on('publish:success', data => {
+    wsBroadcast('publish:success', data)
+    appendNodeLog({
+      event: 'node:publish:success',
+      message: 'File published and seeding',
+      data: { cid: data.cid, fileName: data.fileName },
+    })
+    safeBroadcastNodeStatus()
+  })
   engine.on('connection', () => {
     wsBroadcast('network:status', engine.getNetworkStatus())
+    safeBroadcastNodeStatus()
+  })
+  engine.on('holding:updated', data => {
+    appendNodeLog({
+      event: 'node:holding:updated',
+      message: 'Holding metadata updated',
+      data: { cid: data.cid, size: data.size },
+    })
+    safeBroadcastNodeStatus()
+  })
+  engine.on('holding:removed', data => {
+    appendNodeLog({
+      event: 'node:holding:removed',
+      message: 'Holding metadata removed',
+      data,
+    })
+    safeBroadcastNodeStatus()
+  })
+  engine.on('file:topic:joined', data => {
+    appendNodeLog({
+      event: 'node:topic:joined',
+      message: 'CID topic joined',
+      data,
+    })
+    safeBroadcastNodeStatus()
   })
   engine.on('channel:message', data =>
     wsSendToChannel(data.channel, 'channel:message', data)
@@ -897,7 +1347,14 @@ export async function main() {
   engine.on('channel:left', data => wsBroadcast('channel:left', data))
 
   await engine.start()
+  engineReadyForStatus = true
   console.log('[MostBox] Engine ready')
+  appendNodeLog({
+    event: 'node:ready',
+    message: 'Node daemon ready',
+    data: { dataPath, port: PORT },
+  })
+  broadcastNodeStatus()
 
   serverInstanceRef.current = serve(
     { fetch: app.fetch, port: PORT, hostname: HOST },