most-box 0.3.4 → 0.3.6

package/server/index.js

@@ -143,6 +143,9 @@ function bindEngineEvents({
   engine.on('channel:presence', data =>
     wsSendToChannel(data.channelKey, 'channel:presence', data)
   )
+  engine.on('channel:voice', data =>
+    wsSendToChannel(data.channelKey, 'channel:voice', data)
+  )
   engine.on('channel:joined', data => wsBroadcast('channel:joined', data))
   engine.on('channel:left', data => wsBroadcast('channel:left', data))
   engine.on('user:metadata:updated', data => {
@@ -162,7 +165,7 @@ function bindEngineEvents({
   }
 }
 
-function createWebSocketServer({
+export function createWebSocketServer({
   engine,
   serverInstance,
   validateWebSocketRequest,
@@ -247,6 +250,20 @@ function createWebSocketServer({
               })
             }
             break
+          case 'channel:voice:join':
+          case 'channel:voice:state':
+          case 'channel:voice:heartbeat':
+          case 'channel:voice:leave':
+          case 'channel:voice:signal':
+            if (data.channel && ws.userAddress) {
+              engine.sendChannelVoiceEvent(data.channel, {
+                ...data,
+                event: event.replace('channel:voice:', ''),
+              }, {
+                ownerAddress: ws.userAddress,
+              })
+            }
+            break
         }
       } catch (err) {
         console.error('[WS Message Error]', err.message)

package/server/src/core/channelVoice.js

@@ -0,0 +1,164 @@
+import {
+  buildChannelKey,
+  normalizeChannelAvatar,
+  normalizeChannelDisplayName,
+  normalizeChannelId,
+} from './channelIdentity.js'
+import { normalizeOwnerAddress } from './ownerMetadata.js'
+import { ValidationError } from '../utils/errors.js'
+
+export const CHANNEL_VOICE_EVENTS = new Set([
+  'join',
+  'state',
+  'heartbeat',
+  'leave',
+  'signal',
+])
+
+const CHANNEL_VOICE_SIGNAL_TYPES = new Set(['offer', 'answer', 'candidate'])
+const CHANNEL_VOICE_SESSION_REGEX = /^[a-zA-Z0-9_-]{3,80}$/
+const CHANNEL_VOICE_SIGNAL_MAX_BYTES = 64 * 1024
+
+function normalizeSessionId(value, label = 'voice session') {
+  const sessionId = String(value || '').trim()
+  if (!CHANNEL_VOICE_SESSION_REGEX.test(sessionId)) {
+    throw new ValidationError(`Invalid ${label}`)
+  }
+  return sessionId
+}
+
+function assertPayloadSize(value, message) {
+  const size = Buffer.byteLength(JSON.stringify(value || {}), 'utf8')
+  if (size > CHANNEL_VOICE_SIGNAL_MAX_BYTES) {
+    throw new ValidationError(message)
+  }
+}
+
+function normalizeSignal(input) {
+  if (!input || typeof input !== 'object' || Array.isArray(input)) {
+    throw new ValidationError('voice signal is required')
+  }
+
+  assertPayloadSize(input, 'voice signal is too large')
+
+  const type = String(input.type || '').trim()
+  if (!CHANNEL_VOICE_SIGNAL_TYPES.has(type)) {
+    throw new ValidationError('Invalid voice signal type')
+  }
+
+  if (type === 'offer' || type === 'answer') {
+    const sdp = String(input.sdp || '')
+    if (!sdp.trim()) {
+      throw new ValidationError('voice signal SDP is required')
+    }
+    return { type, sdp }
+  }
+
+  if (
+    !input.candidate ||
+    typeof input.candidate !== 'object' ||
+    Array.isArray(input.candidate)
+  ) {
+    throw new ValidationError('voice signal candidate is required')
+  }
+
+  const candidate = {
+    candidate: String(input.candidate.candidate || ''),
+    sdpMid:
+      input.candidate.sdpMid === null || input.candidate.sdpMid === undefined
+        ? null
+        : String(input.candidate.sdpMid),
+    sdpMLineIndex:
+      input.candidate.sdpMLineIndex === null ||
+      input.candidate.sdpMLineIndex === undefined
+        ? null
+        : Number(input.candidate.sdpMLineIndex),
+  }
+  if (
+    input.candidate.usernameFragment !== null &&
+    input.candidate.usernameFragment !== undefined
+  ) {
+    candidate.usernameFragment = String(input.candidate.usernameFragment)
+  }
+
+  return {
+    type,
+    candidate,
+  }
+}
+
+export function normalizeChannelVoiceEvent(
+  channelInput,
+  input = {},
+  options = {}
+) {
+  const channelId = normalizeChannelId(channelInput)
+  if (!channelId) {
+    throw new ValidationError('voice channel is required')
+  }
+
+  const ownerAddress = normalizeOwnerAddress(options.ownerAddress)
+  const inputSender =
+    input.sender && typeof input.sender === 'object' && !Array.isArray(input.sender)
+      ? input.sender
+      : {}
+  const senderAddress = ownerAddress || normalizeOwnerAddress(inputSender.address)
+  if (!senderAddress) {
+    throw new ValidationError('voice sender is required')
+  }
+
+  const event = String(input.event || '').trim()
+  if (!CHANNEL_VOICE_EVENTS.has(event)) {
+    throw new ValidationError('Invalid voice event')
+  }
+
+  const sessionId = normalizeSessionId(input.sessionId)
+  const channelKey = buildChannelKey(channelId)
+  const normalized = {
+    channel: channelKey,
+    channelKey,
+    channelId,
+    event,
+    sessionId,
+    sender: {
+      address: senderAddress,
+    },
+    timestamp: Number(options.timestamp) || Date.now(),
+  }
+
+  const displayName = normalizeChannelDisplayName(
+    input.displayName ?? inputSender.displayName,
+    senderAddress
+  )
+  if (displayName) normalized.sender.displayName = displayName
+
+  const avatar = normalizeChannelAvatar(input.avatar ?? inputSender.avatar)
+  if (avatar) normalized.sender.avatar = avatar
+
+  const profileUpdatedAt = Number(
+    input.profileUpdatedAt ?? inputSender.profileUpdatedAt
+  )
+  if (Number.isFinite(profileUpdatedAt) && profileUpdatedAt > 0) {
+    normalized.sender.profileUpdatedAt = profileUpdatedAt
+  }
+
+  if (input.micMuted !== undefined) {
+    normalized.micMuted = Boolean(input.micMuted)
+  }
+
+  if (event === 'signal') {
+    normalized.targetSessionId = normalizeSessionId(
+      input.targetSessionId,
+      'voice target session'
+    )
+    normalized.signal = normalizeSignal(input.signal)
+  } else if (input.targetSessionId) {
+    normalized.targetSessionId = normalizeSessionId(
+      input.targetSessionId,
+      'voice target session'
+    )
+  }
+
+  assertPayloadSize(normalized, 'voice event is too large')
+  return normalized
+}

package/server/src/core/mostLink.js

@@ -24,6 +24,16 @@ function invalidLink(errorCode, details) {
   }
 }
 
+function extractTailTarget(value) {
+  const queryStart = value.indexOf('?')
+  const pathPart = queryStart === -1 ? value : value.slice(0, queryStart)
+  const queryPart = queryStart === -1 ? '' : value.slice(queryStart)
+  const slashIndex = pathPart.lastIndexOf('/')
+  const tailPath = slashIndex === -1 ? pathPart : pathPart.slice(slashIndex + 1)
+
+  return `${tailPath}${queryPart}`
+}
+
 /**
  * 验证 CID 字符串
  * @param {string} cidString - 要验证的 CID 字符串
@@ -62,27 +72,34 @@ export function parseMostLink(link) {
     return invalidLink(MOST_LINK_ERROR_CODES.LINK_EMPTY)
   }
 
-  let url
-  try {
-    url = new URL(link)
-  } catch {
-    return invalidLink(MOST_LINK_ERROR_CODES.INVALID_URL)
+  const value = link.trim()
+  if (!value) {
+    return invalidLink(MOST_LINK_ERROR_CODES.LINK_EMPTY)
   }
 
-  if (url.protocol !== 'most:') {
-    return invalidLink(MOST_LINK_ERROR_CODES.INVALID_PROTOCOL)
-  }
+  const tailTarget = extractTailTarget(value)
+  const queryStart = tailTarget.indexOf('?')
+  const cidString =
+    queryStart === -1 ? tailTarget : tailTarget.slice(0, queryStart)
+  const queryString =
+    queryStart === -1 ? '' : tailTarget.slice(queryStart + 1)
 
-  if (url.pathname && url.pathname !== '/') {
-    return invalidLink(MOST_LINK_ERROR_CODES.UNSUPPORTED_PATH)
+  if (!cidString) {
+    return invalidLink(MOST_LINK_ERROR_CODES.INVALID_CID_FORMAT)
   }
 
-  const cidString = url.hostname
-  const rawFileName = url.searchParams.get('filename')
-  const unsupportedParam = [...url.searchParams.keys()].find(
+  const searchParams = new URLSearchParams(queryString)
+  const rawFileName = searchParams.get('filename')
+  const unsupportedParam = [...searchParams.keys()].find(
     key => key !== 'filename'
   )
 
+  if (queryString && ![...searchParams.keys()].length) {
+    return invalidLink(MOST_LINK_ERROR_CODES.UNSUPPORTED_QUERY_PARAM, {
+      param: '',
+    })
+  }
+
   const validation = validateCidString(cidString)
   if (!validation.valid) {
     return invalidLink(validation.errorCode)

package/server/src/http/nodeStatus.js

@@ -214,13 +214,13 @@ export function buildOpenApiSpec(appPort) {
       '/api/download/check': {
         post: {
           summary:
-            'Check whether a most:// link is locally available or discoverable',
+            'Check whether a CID-tailed share target is locally available or discoverable',
           responses: { 200: { description: 'Download availability result' } },
         },
       },
       '/api/download': {
         post: {
-          summary: 'Start downloading a most:// link',
+          summary: 'Start downloading a CID-tailed share target',
           responses: { 200: { description: 'Download task result' } },
         },
       },

package/server/src/http/routes/fileRoutes.js

@@ -15,10 +15,15 @@ export function registerFileRoutes(app, { engine, configStore, wsBroadcast }) {
 
   app.post('/api/publish', async c => {
     const req = c.env.incoming
-    const result = await parseMultipartBusboy(
-      req,
-      configStore.getNodeConfig().maxFileSizeBytes
-    )
+    let result
+    try {
+      result = await parseMultipartBusboy(
+        req,
+        configStore.getNodeConfig().maxFileSizeBytes
+      )
+    } catch (err) {
+      return badRequestOrAppError(c, err)
+    }
 
     if (!result || !result.filename) {
       return c.json({ error: 'No file provided' }, 400)
@@ -56,11 +61,8 @@ export function registerFileRoutes(app, { engine, configStore, wsBroadcast }) {
     if (localAvailability) {
       return c.json({
         success: true,
-        available: true,
-        cid: parsed.cid,
-        fileName: localAvailability.fileName,
+        ...localAvailability,
         size: Number(localAvailability.size) || null,
-        alreadyExists: true,
       })
     }
 

package/server/src/http/uploads.js

@@ -3,6 +3,7 @@ import path from 'node:path'
 import os from 'node:os'
 import Busboy from 'busboy'
 import { MAX_FILE_SIZE } from '../config.js'
+import { FileSizeError } from '../utils/errors.js'
 
 export const UPLOAD_TMP_DIR = path.join(os.tmpdir(), 'most-box-uploads')
 
@@ -56,10 +57,34 @@ export async function parseMultipartBusboy(req, maxUploadSize = MAX_FILE_SIZE) {
 
     const result = { filePath: null, filename: null }
     let fileSize = 0
+    let activeFileStream = null
     let writeStream = null
     let tempPath = null
+    let settled = false
+
+    function cleanupTempFile() {
+      if (tempPath) fs.unlink(tempPath, () => {})
+    }
+
+    function fail(err) {
+      if (settled) return
+      settled = true
+      if (activeFileStream && !activeFileStream.destroyed) {
+        activeFileStream.destroy()
+      }
+      if (writeStream && !writeStream.destroyed) writeStream.destroy()
+      cleanupTempFile()
+      reject(err)
+    }
+
+    function succeed(value) {
+      if (settled) return
+      settled = true
+      resolve(value)
+    }
 
     busboy.on('file', (name, stream, info) => {
+      activeFileStream = stream
       result.filename = decodeFilenameFromHeader(`filename="${info.filename}"`)
       tempPath = path.join(
         UPLOAD_TMP_DIR,
@@ -70,45 +95,58 @@ export async function parseMultipartBusboy(req, maxUploadSize = MAX_FILE_SIZE) {
       stream.on('data', chunk => {
         fileSize += chunk.length
         if (fileSize > maxUploadSize) {
-          stream.destroy()
-          writeStream.destroy()
-          fs.unlink(tempPath, () => {})
-          reject(new Error('File too large'))
-          return
+          fail(new FileSizeError('File too large', fileSize, maxUploadSize))
         }
       })
 
-      stream.on('error', () => {
-        if (tempPath) fs.unlink(tempPath, () => {})
+      stream.on('limit', () => {
+        fail(
+          new FileSizeError(
+            'File too large',
+            fileSize || maxUploadSize,
+            maxUploadSize
+          )
+        )
+      })
+
+      stream.on('error', err => {
+        fail(err)
       })
 
       stream.pipe(writeStream)
 
       writeStream.on('finish', () => {
+        if (stream.truncated) {
+          fail(
+            new FileSizeError(
+              'File too large',
+              fileSize || maxUploadSize,
+              maxUploadSize
+            )
+          )
+          return
+        }
         result.filePath = tempPath
-        resolve(result)
+        succeed(result)
       })
 
       writeStream.on('error', err => {
-        if (tempPath) fs.unlink(tempPath, () => {})
-        reject(err)
+        fail(err)
       })
     })
 
     busboy.on('error', err => {
-      if (tempPath) fs.unlink(tempPath, () => {})
-      reject(err)
+      fail(err)
     })
 
     busboy.on('close', () => {
       if (!result.filename) {
-        resolve(null)
+        succeed(null)
       }
     })
 
     req.on('error', err => {
-      if (tempPath) fs.unlink(tempPath, () => {})
-      reject(err)
+      fail(err)
     })
     req.pipe(busboy)
   })