most-box 0.1.0 → 0.1.1

package/server/src/node/config.js

@@ -0,0 +1,159 @@
+import fs from 'node:fs'
+import os from 'node:os'
+import path from 'node:path'
+import { MAX_FILE_SIZE } from '../config.js'
+
+const DEFAULT_CONFIG_DIR_NAME = '.most-box'
+const DEFAULT_DATA_DIR_NAME = 'most-data'
+const DEFAULT_CAPACITY_BYTES = 100 * 1024 * 1024 * 1024
+
+export function getDefaultConfigDir() {
+  return process.env.MOSTBOX_CONFIG_DIR
+    ? path.resolve(process.env.MOSTBOX_CONFIG_DIR)
+    : path.join(os.homedir(), DEFAULT_CONFIG_DIR_NAME)
+}
+
+export function getDefaultDataPath() {
+  return path.join(os.homedir(), DEFAULT_DATA_DIR_NAME)
+}
+
+export function getDefaultNodeConfig() {
+  return {
+    dataPath: '',
+    capacityBytes: DEFAULT_CAPACITY_BYTES,
+    maxFileSizeBytes: MAX_FILE_SIZE,
+  }
+}
+
+export function normalizeNodeConfig(raw = {}) {
+  const defaults = getDefaultNodeConfig()
+  const rawNode = raw.node && typeof raw.node === 'object' ? raw.node : {}
+
+  const capacityBytes = normalizePositiveInteger(
+    rawNode.capacityBytes ?? raw.capacityBytes,
+    defaults.capacityBytes
+  )
+  const maxFileSizeBytes = normalizePositiveInteger(
+    rawNode.maxFileSizeBytes ?? raw.maxFileSizeBytes,
+    defaults.maxFileSizeBytes
+  )
+  return {
+    dataPath:
+      typeof raw.dataPath === 'string'
+        ? raw.dataPath.trim()
+        : defaults.dataPath,
+    capacityBytes,
+    maxFileSizeBytes,
+  }
+}
+
+export function createNodeConfigStore(configDir = getDefaultConfigDir()) {
+  const resolvedConfigDir = path.resolve(configDir)
+  const configFile = path.join(resolvedConfigDir, 'config.json')
+
+  function loadRawConfig() {
+    try {
+      if (fs.existsSync(configFile)) {
+        return JSON.parse(fs.readFileSync(configFile, 'utf-8'))
+      }
+    } catch (err) {
+      console.error('[Config] Load error:', err.message)
+    }
+    return {}
+  }
+
+  function saveRawConfig(config) {
+    try {
+      if (!fs.existsSync(resolvedConfigDir)) {
+        fs.mkdirSync(resolvedConfigDir, { recursive: true })
+      }
+      const tmpPath = configFile + '.tmp'
+      fs.writeFileSync(tmpPath, JSON.stringify(config, null, 2), 'utf-8')
+      fs.renameSync(tmpPath, configFile)
+      return true
+    } catch (err) {
+      console.error('[Config] Save error:', err.message)
+      return false
+    }
+  }
+
+  function getNodeConfig() {
+    return normalizeNodeConfig(loadRawConfig())
+  }
+
+  function getDataPath() {
+    if (process.env.MOSTBOX_DATA_PATH) {
+      return process.env.MOSTBOX_DATA_PATH
+    }
+    return getNodeConfig().dataPath || getDefaultDataPath()
+  }
+
+  function saveNodeConfigPatch(patch = {}) {
+    const raw = loadRawConfig()
+    const current = normalizeNodeConfig(raw)
+    const next = normalizeNodeConfig({
+      ...raw,
+      dataPath:
+        patch.dataPath === undefined ? current.dataPath : patch.dataPath,
+      node: {
+        ...(raw.node && typeof raw.node === 'object' ? raw.node : {}),
+        capacityBytes:
+          patch.capacityBytes === undefined
+            ? current.capacityBytes
+            : patch.capacityBytes,
+        maxFileSizeBytes:
+          patch.maxFileSizeBytes === undefined
+            ? current.maxFileSizeBytes
+            : patch.maxFileSizeBytes,
+      },
+    })
+
+    const saved = {
+      dataPath: next.dataPath,
+      node: {
+        capacityBytes: next.capacityBytes,
+        maxFileSizeBytes: next.maxFileSizeBytes,
+        updatedAt: new Date().toISOString(),
+      },
+    }
+
+    return { success: saveRawConfig(saved), config: normalizeNodeConfig(saved) }
+  }
+
+  return {
+    configDir: resolvedConfigDir,
+    configFile,
+    loadRawConfig,
+    saveRawConfig,
+    getNodeConfig,
+    getDataPath,
+    saveNodeConfigPatch,
+  }
+}
+
+export function evaluateStorageLimits(config, input = {}) {
+  const size = Number(input.size ?? input.fileSize ?? 0)
+  const reasons = []
+
+  if (!Number.isFinite(size) || size < 0) {
+    reasons.push('invalid-size')
+  } else if (size > config.maxFileSizeBytes) {
+    reasons.push('file-too-large')
+  } else if (size > config.capacityBytes) {
+    reasons.push('capacity-too-small')
+  }
+
+  return {
+    accepted: reasons.length === 0,
+    reasons,
+    policy: config,
+  }
+}
+
+function normalizePositiveInteger(value, fallback) {
+  const parsed = Number(value)
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    return fallback
+  }
+  return Math.floor(parsed)
+}

package/server/src/node/logs.js

@@ -0,0 +1,94 @@
+import fs from 'node:fs'
+import path from 'node:path'
+
+const DEFAULT_MAX_LOG_LINES = 1000
+
+export function createNodeLogger(configDir, options = {}) {
+  const maxLines = options.maxLines || DEFAULT_MAX_LOG_LINES
+  const logFile = options.logFile || path.join(configDir, 'node-events.log')
+
+  function append(input = {}) {
+    const entry = {
+      id: `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      ts: new Date().toISOString(),
+      level: input.level || 'info',
+      event: input.event || 'node:event',
+      message: input.message || input.event || 'Node event',
+      data: input.data || {},
+    }
+
+    try {
+      const logDir = path.dirname(logFile)
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true })
+      }
+      fs.appendFileSync(logFile, `${JSON.stringify(entry)}\n`, 'utf-8')
+      trimLogFile()
+    } catch (err) {
+      console.warn('[NodeLog] Failed to append:', err.message)
+    }
+
+    return entry
+  }
+
+  function list(limit = 100) {
+    try {
+      if (!fs.existsSync(logFile)) return []
+      const lines = fs
+        .readFileSync(logFile, 'utf-8')
+        .split('\n')
+        .filter(Boolean)
+      return lines
+        .slice(-Math.max(1, Math.min(Number(limit) || 100, maxLines)))
+        .map(line => {
+          try {
+            return JSON.parse(line)
+          } catch {
+            return null
+          }
+        })
+        .filter(Boolean)
+        .reverse()
+    } catch (err) {
+      console.warn('[NodeLog] Failed to read:', err.message)
+      return []
+    }
+  }
+
+  function clear() {
+    try {
+      const logDir = path.dirname(logFile)
+      if (!fs.existsSync(logDir)) {
+        fs.mkdirSync(logDir, { recursive: true })
+      }
+      fs.writeFileSync(logFile, '', 'utf-8')
+      return true
+    } catch (err) {
+      console.warn('[NodeLog] Failed to clear:', err.message)
+      return false
+    }
+  }
+
+  function trimLogFile() {
+    try {
+      if (!fs.existsSync(logFile)) return
+      const lines = fs
+        .readFileSync(logFile, 'utf-8')
+        .split('\n')
+        .filter(Boolean)
+      if (lines.length <= maxLines) return
+      fs.writeFileSync(
+        logFile,
+        `${lines.slice(-maxLines).join('\n')}\n`,
+        'utf-8'
+      )
+    } catch {}
+  }
+
+  return {
+    logFile,
+    append,
+    list,
+    clear,
+  }
+}

package/server/src/utils/api.js

@@ -1,10 +1,28 @@
 import ky from 'ky'
 
 const STORAGE_KEY = 'mostbox_backend_url'
+const LOCALHOST_BACKEND_URL = 'http://localhost:1976'
+
+function isLocalFrontendOrigin() {
+  if (typeof window === 'undefined') return false
+
+  return (
+    ['localhost', '127.0.0.1'].includes(window.location.hostname) &&
+    window.location.port === '3000'
+  )
+}
+
+function getDefaultBackendUrl() {
+  return isLocalFrontendOrigin() ? LOCALHOST_BACKEND_URL : ''
+}
 
 function getBackendUrl() {
   if (typeof window === 'undefined') return ''
-  return localStorage.getItem(STORAGE_KEY) || ''
+  return localStorage.getItem(STORAGE_KEY) || getDefaultBackendUrl()
+}
+
+function normalizePath(path) {
+  return path.startsWith('/') ? path : `/${path}`
 }
 
 function createApiInstance() {
@@ -16,6 +34,50 @@ function createApiInstance() {
 
 export let api = createApiInstance()
 
+export async function getApiErrorPayload(err) {
+  const response =
+    err && typeof err === 'object' && 'response' in err
+      ? err.response
+      : err instanceof Response
+        ? err
+        : null
+
+  if (!response) return {}
+
+  const data = response.bodyUsed
+    ? null
+    : await response
+        .clone()
+        .json()
+        .catch(() => null)
+
+  return {
+    status: response.status,
+    code: typeof data?.code === 'string' ? data.code : undefined,
+    error:
+      typeof data?.error === 'string'
+        ? data.error
+        : typeof data?.message === 'string'
+          ? data.message
+          : undefined,
+  }
+}
+
+export async function getApiErrorMessage(err, fallback = '请求失败') {
+  const data = await getApiErrorPayload(err)
+  if (data.error) return data.error
+
+  const errorName =
+    err && typeof err === 'object' && 'name' in err ? String(err.name) : ''
+  if (errorName === 'TimeoutError') return '请求超时，请稍后重试'
+
+  if (!data.status && err instanceof Error && err.message) {
+    return err.message
+  }
+
+  return fallback
+}
+
 export function setBackendUrl(url) {
   const cleaned = (url || '').trim().replace(/\/+$/, '')
   if (cleaned) {
@@ -30,6 +92,20 @@ export function getBackendUrlExport() {
   return getBackendUrl()
 }
 
+export function getApiUrl(path) {
+  const url = getBackendUrl()
+  return `${url}${normalizePath(path)}`
+}
+
+export function getWebSocketUrl(path = '/ws') {
+  if (typeof window === 'undefined') return normalizePath(path)
+
+  const base = getBackendUrl() || window.location.origin
+  const url = new URL(normalizePath(path), base)
+  url.protocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+  return url.toString()
+}
+
 export async function checkBackendConnection() {
   const url = getBackendUrl()
   try {
@@ -44,6 +120,8 @@ export async function checkBackendConnection() {
 }
 
 export async function detectSameOriginBackend() {
+  if (isLocalFrontendOrigin()) return false
+
   try {
     const res = await fetch('/api/node-id', {
       method: 'GET',
@@ -57,7 +135,7 @@ export async function detectSameOriginBackend() {
 
 export async function detectLocalhostBackend() {
   try {
-    const res = await fetch('http://localhost:1976/api/node-id', {
+    const res = await fetch(`${LOCALHOST_BACKEND_URL}/api/node-id`, {
       method: 'GET',
       signal: AbortSignal.timeout(2000),
     })

package/server/src/utils/errors.js

@@ -58,6 +58,13 @@ export class PermissionError extends AppError {
   }
 }
 
+export class ConflictError extends AppError {
+  constructor(message = 'Resource conflict') {
+    super(message, 'CONFLICT')
+    this.name = 'ConflictError'
+  }
+}
+
 export class EngineNotInitializedError extends AppError {
   constructor(message = 'Engine not initialized. Call start() first.') {
     super(message, 'ENGINE_NOT_INITIALIZED')

package/server/src/utils/mostWallet.js

@@ -1,4 +1,6 @@
 import {
+  decodeBase64,
+  encodeBase64,
   pbkdf2,
   sha256,
   getBytes,
@@ -10,7 +12,7 @@ import {
 import nacl from 'tweetnacl'
 
 const SALT_PREFIX = '/most.box/'
-const PBKDF2_ITERATIONS = 3
+const PBKDF2_ITERATIONS = 50_000
 const PBKDF2_KEY_LENGTH = 32
 
 export function mostWallet(username, password) {
@@ -40,3 +42,34 @@ export function most25519(danger) {
     ed_public_key: hexlify(ed25519KeyPair.publicKey),
   }
 }
+
+export async function mostSignMessage(danger, message) {
+  const account = HDNodeWallet.fromPhrase(mostMnemonic(danger))
+  return {
+    address: account.address,
+    signature: await account.signMessage(message),
+  }
+}
+
+export function mostEncode(text, danger) {
+  const bytes = new TextEncoder().encode(text)
+  const nonce = nacl.randomBytes(nacl.secretbox.nonceLength)
+  const key = getBytes(danger).slice(0, nacl.secretbox.keyLength)
+  const encrypted = nacl.secretbox(bytes, nonce, key)
+
+  return ['mp://1', encodeBase64(nonce), encodeBase64(encrypted)].join('.')
+}
+
+export function mostDecode(data, danger) {
+  const [prefix, nonce64, encrypted64] = String(data || '').split('.')
+  if (prefix !== 'mp://1' || !nonce64 || !encrypted64) return ''
+
+  const key = getBytes(danger).slice(0, nacl.secretbox.keyLength)
+  const decrypted = nacl.secretbox.open(
+    decodeBase64(encrypted64),
+    decodeBase64(nonce64),
+    key
+  )
+
+  return decrypted ? new TextDecoder().decode(decrypted) : ''
+}

package/server/src/utils/noteBackup.js

@@ -0,0 +1,119 @@
+import { mostDecode, mostEncode, mostSignMessage } from './mostWallet.js'
+import { calculateNoteCid } from './noteUtils.js'
+
+export const NOTE_BACKUP_API_URL = 'https://api.most.box/api/backup'
+
+async function readBackupApiError(response, fallback) {
+  const data = await response
+    .clone()
+    .json()
+    .catch(() => null)
+  return data?.error || fallback
+}
+
+export function encryptNotesBackup(notes, danger) {
+  return mostEncode(JSON.stringify({ notes: notes || [] }), danger)
+}
+
+export function decryptNotesBackup(content, danger) {
+  if (!String(content || '').startsWith('mp://1')) {
+    throw new Error('无效的备份数据格式')
+  }
+
+  const decrypted = mostDecode(content, danger)
+  if (!decrypted) {
+    throw new Error('解密失败，请确认当前 Web3 登录账号正确')
+  }
+
+  const data = JSON.parse(decrypted)
+  if (!Array.isArray(data.notes)) {
+    throw new Error('备份数据缺少 notes')
+  }
+  return data
+}
+
+export async function calculateNotesBackupCid(notes) {
+  return calculateNoteCid(JSON.stringify({ notes: notes || [] }))
+}
+
+export async function getBackupAuthHeaders(
+  wallet,
+  method,
+  url = NOTE_BACKUP_API_URL
+) {
+  const timestamp = Date.now().toString()
+  const path = new URL(url).pathname
+  const message = `${timestamp}:${String(method).toUpperCase()}:${path}`
+  const { address, signature } = await mostSignMessage(wallet.danger, message)
+  return {
+    Authorization: `${address},${timestamp},${signature}`,
+  }
+}
+
+export async function buildNotesBackupUpload(wallet, notes) {
+  const payload = JSON.stringify({ notes: notes || [] })
+  const cid = await calculateNoteCid(payload)
+  const encrypted = encryptNotesBackup(notes, wallet.danger)
+  return {
+    cid,
+    body: encrypted,
+    headers: {
+      'Content-Type': 'text/plain',
+      'x-backup-cid': cid,
+      ...(await getBackupAuthHeaders(wallet, 'PUT', NOTE_BACKUP_API_URL)),
+    },
+  }
+}
+
+export async function uploadNotesBackup(
+  wallet,
+  notes,
+  url = NOTE_BACKUP_API_URL
+) {
+  const upload = await buildNotesBackupUpload(wallet, notes)
+  const response = await fetch(url, {
+    method: 'PUT',
+    headers: upload.headers,
+    body: upload.body,
+  })
+  if (!response.ok) {
+    throw new Error(await readBackupApiError(response, '云备份失败'))
+  }
+  return {
+    cid: upload.cid,
+  }
+}
+
+export async function downloadNotesBackup(
+  wallet,
+  url = NOTE_BACKUP_API_URL
+) {
+  const response = await fetch(url, {
+    method: 'GET',
+    headers: await getBackupAuthHeaders(wallet, 'GET', url),
+  })
+  if (response.status === 404) {
+    return {
+      found: false,
+      cid: '',
+      time: 0,
+      notes: [],
+    }
+  }
+  if (!response.ok) {
+    throw new Error(await readBackupApiError(response, '云端恢复失败'))
+  }
+
+  const encrypted = await response.text()
+  if (!encrypted) {
+    throw new Error('云端无备份数据')
+  }
+
+  const data = decryptNotesBackup(encrypted, wallet.danger)
+  return {
+    found: true,
+    cid: response.headers.get('x-backup-cid') || '',
+    time: Number(response.headers.get('x-backup-time') || 0),
+    notes: data.notes,
+  }
+}

package/server/src/utils/noteUtils.js

@@ -0,0 +1,120 @@
+import { CID } from 'multiformats/cid'
+import * as raw from 'multiformats/codecs/raw'
+import { sha256 } from 'multiformats/hashes/sha2'
+
+export function normalizeNotePath(input = '') {
+  return String(input)
+    .replace(/\\/g, '/')
+    .split('/')
+    .map(part => part.trim())
+    .filter(part => part && part !== '.')
+    .filter(part => part !== '..')
+    .join('/')
+}
+
+export function getNoteFullPath(note) {
+  const path = normalizeNotePath(note?.path || '')
+  const name = String(note?.name || '').trim()
+  return path ? `${path}/${name}` : name
+}
+
+export function validateNoteName(name) {
+  const value = String(name || '').trim()
+  if (!value) return { valid: false, error: '请输入名称' }
+  if (value.includes('/')) return { valid: false, error: '名称不能包含 /' }
+  if (value.includes('\\')) return { valid: false, error: '名称不能包含 \\' }
+  return { valid: true, name: value }
+}
+
+export async function calculateNoteCid(content = '') {
+  const bytes = new TextEncoder().encode(String(content))
+  const hash = await sha256.digest(bytes)
+  return CID.create(1, raw.code, hash).toString()
+}
+
+export function filterNotesByPath(notes, currentPath = '', query = '') {
+  const normalizedCurrentPath = normalizeNotePath(currentPath)
+  const normalizedQuery = query.trim().toLowerCase()
+  const files = Array.isArray(notes) ? notes : []
+
+  if (normalizedQuery) {
+    return files
+      .filter(note => String(note.name || '').toLowerCase().includes(normalizedQuery))
+      .sort(sortNotesForExplorer)
+  }
+
+  const directItems = []
+  const inferredDirs = new Map()
+
+  for (const note of files) {
+    const notePath = normalizeNotePath(note.path || '')
+
+    if (notePath === normalizedCurrentPath) {
+      directItems.push(note)
+      continue
+    }
+
+    if (
+      normalizedCurrentPath === '' ||
+      notePath.startsWith(`${normalizedCurrentPath}/`)
+    ) {
+      const relativePath =
+        normalizedCurrentPath === ''
+          ? notePath
+          : notePath.slice(normalizedCurrentPath.length + 1)
+      const firstSegment = relativePath.split('/').filter(Boolean)[0]
+
+      if (firstSegment && !inferredDirs.has(firstSegment)) {
+        inferredDirs.set(firstSegment, {
+          name: firstSegment,
+          type: 'directory',
+          path: normalizedCurrentPath,
+          size: 0,
+          cid: `__dir__${normalizedCurrentPath}/${firstSegment}`,
+          created_at: note.created_at || Date.now(),
+          updated_at: note.updated_at || note.created_at || Date.now(),
+        })
+      }
+    }
+  }
+
+  return [...inferredDirs.values(), ...directItems].sort(sortNotesForExplorer)
+}
+
+export function renameNotesByPath(notes, oldFullPath, targetPath, targetName) {
+  const oldPath = normalizeNotePath(oldFullPath)
+  const newPath = normalizeNotePath(targetPath)
+  const cleanName = String(targetName || '').trim()
+  const targetFullPath = normalizeNotePath(
+    newPath ? `${newPath}/${cleanName}` : cleanName
+  )
+  const now = Date.now()
+
+  return notes.map(note => {
+    const fullPath = getNoteFullPath(note)
+
+    if (fullPath === oldPath) {
+      return { ...note, path: newPath, name: cleanName, updated_at: now }
+    }
+
+    if (fullPath.startsWith(`${oldPath}/`)) {
+      const relativePath = fullPath.slice(oldPath.length + 1)
+      const nextFullPath = normalizeNotePath(`${targetFullPath}/${relativePath}`)
+      const lastSlash = nextFullPath.lastIndexOf('/')
+      return {
+        ...note,
+        path: lastSlash === -1 ? '' : nextFullPath.slice(0, lastSlash),
+        name: nextFullPath.slice(lastSlash + 1),
+        updated_at: now,
+      }
+    }
+
+    return note
+  })
+}
+
+function sortNotesForExplorer(a, b) {
+  if (a.type === 'directory' && b.type !== 'directory') return -1
+  if (a.type !== 'directory' && b.type === 'directory') return 1
+  return (b.updated_at || b.created_at || 0) - (a.updated_at || a.created_at || 0)
+}