most-box 0.1.0 → 0.1.2

package/server/src/node/config.js

@@ -0,0 +1,191 @@
+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 const DEFAULT_NODE_PORT = 1976
+export const DEFAULT_NODE_HOST = '127.0.0.1'
+
+export function getDefaultConfigDir() {
+  return 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: '',
+    host: DEFAULT_NODE_HOST,
+    port: DEFAULT_NODE_PORT,
+    capacityBytes: DEFAULT_CAPACITY_BYTES,
+    maxFileSizeBytes: MAX_FILE_SIZE,
+    remoteInvites: [],
+  }
+}
+
+export function normalizeRemoteInvites(value = []) {
+  const items = Array.isArray(value) ? value : String(value || '').split(',')
+  return Array.from(
+    new Set(items.map(item => String(item || '').trim()).filter(Boolean))
+  )
+}
+
+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
+  )
+  const remoteInvites = normalizeRemoteInvites(
+    rawNode.remoteInvites ?? raw.remoteInvites ?? defaults.remoteInvites
+  )
+  const host = normalizeHost(rawNode.host ?? raw.host, defaults.host)
+  const port = normalizePositiveInteger(
+    rawNode.port ?? raw.port,
+    defaults.port
+  )
+  return {
+    dataPath:
+      typeof raw.dataPath === 'string'
+        ? raw.dataPath.trim()
+        : defaults.dataPath,
+    host,
+    port,
+    capacityBytes,
+    maxFileSizeBytes,
+    remoteInvites,
+  }
+}
+
+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() {
+    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 : {}),
+        host: patch.host === undefined ? current.host : patch.host,
+        port: patch.port === undefined ? current.port : patch.port,
+        capacityBytes:
+          patch.capacityBytes === undefined
+            ? current.capacityBytes
+            : patch.capacityBytes,
+        maxFileSizeBytes:
+          patch.maxFileSizeBytes === undefined
+            ? current.maxFileSizeBytes
+            : patch.maxFileSizeBytes,
+        remoteInvites:
+          patch.remoteInvites === undefined
+            ? current.remoteInvites
+            : patch.remoteInvites,
+      },
+    })
+
+    const saved = {
+      dataPath: next.dataPath,
+      node: {
+        host: next.host,
+        port: next.port,
+        capacityBytes: next.capacityBytes,
+        maxFileSizeBytes: next.maxFileSizeBytes,
+        remoteInvites: next.remoteInvites,
+        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)
+}
+
+function normalizeHost(value, fallback) {
+  const host = String(value || '').trim()
+  return host || fallback
+}

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,23 +1,189 @@
 import ky from 'ky'
+import { buildAuthHeaders, normalizeAuthPath } from './auth.js'
 
 const STORAGE_KEY = 'mostbox_backend_url'
+const INVITE_STORAGE_KEY = 'mostbox_backend_invite'
+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)
+}
+
+function getDefaultBackendUrl() {
+  return isLocalFrontendOrigin() ? LOCALHOST_BACKEND_URL : ''
+}
 
 function getBackendUrl() {
+  if (typeof window === 'undefined') return ''
+  return localStorage.getItem(STORAGE_KEY) || getDefaultBackendUrl()
+}
+
+function getConfiguredBackendUrl() {
   if (typeof window === 'undefined') return ''
   return localStorage.getItem(STORAGE_KEY) || ''
 }
 
+function getRemoteBackendUrl() {
+  const configured = getConfiguredBackendUrl()
+  if (!configured) return ''
+  try {
+    const { hostname } = new URL(configured)
+    return ['localhost', '127.0.0.1', '::1'].includes(hostname)
+      ? ''
+      : configured
+  } catch {
+    return configured
+  }
+}
+
+function getBackendInvite() {
+  if (typeof window === 'undefined') return ''
+  return localStorage.getItem(INVITE_STORAGE_KEY) || ''
+}
+
+function normalizeBackendUrl(url) {
+  return (url || '').trim().replace(/\/+$/, '')
+}
+
+function isLocalBackendUrl(url) {
+  const value = normalizeBackendUrl(url)
+  if (!value) return false
+  try {
+    const { hostname } = new URL(value)
+    const normalized = hostname.toLowerCase()
+    return (
+      normalized === 'localhost' ||
+      normalized === '::1' ||
+      normalized === '[::1]' ||
+      normalized === '127.0.0.1' ||
+      normalized.startsWith('127.')
+    )
+  } catch {
+    return false
+  }
+}
+
+function shouldAttachBackendInvite(url = getBackendUrl()) {
+  return Boolean(getBackendInvite()) && !isLocalBackendUrl(url)
+}
+
+function getStoredIdentity() {
+  if (typeof window === 'undefined') return null
+  try {
+    const raw = localStorage.getItem('mostbox_identity')
+    return raw ? JSON.parse(raw) : null
+  } catch {
+    return null
+  }
+}
+
+function normalizePath(path) {
+  return path.startsWith('/') ? path : `/${path}`
+}
+
+function buildWebSocketUrl(base, wsPath = '/ws') {
+  const url = new URL(base)
+  const wsProtocol = url.protocol === 'https:' ? 'wss:' : 'ws:'
+  const basePath = url.pathname.replace(/\/+$/, '')
+  return `${wsProtocol}//${url.host}${basePath}${normalizePath(wsPath)}`
+}
+
 function createApiInstance() {
-  const url = getBackendUrl()
-  return ky.create({
-    prefix: url,
+  const client = ky.create({
+    hooks: {
+      beforeRequest: [
+        async ({ request }) => {
+          const headers = new Headers(request.headers || {})
+          const invite = getBackendInvite()
+          if (invite && shouldAttachBackendInvite(request.url)) {
+            headers.set('x-mostbox-invite', invite)
+          }
+
+          const identity = getStoredIdentity()
+          if (identity?.danger) {
+            try {
+              const authHeaders = await buildAuthHeaders(
+                identity,
+                request.method,
+                normalizeAuthPath(request.url)
+              )
+              for (const [key, value] of Object.entries(authHeaders)) {
+                headers.set(key, value)
+              }
+            } catch {
+              // Ignore invalid legacy identity data for public/backend probes.
+            }
+          }
+          return new Request(request, { headers })
+        },
+      ],
+    },
+  })
+
+  return new Proxy(client, {
+    get(target, prop, receiver) {
+      const value = Reflect.get(target, prop, receiver)
+      if (!['get', 'post', 'put', 'patch', 'delete', 'head'].includes(prop)) {
+        return value
+      }
+      return (input, options) => {
+        const nextInput = typeof input === 'string' ? getApiUrl(input) : input
+        return value.call(target, nextInput, options)
+      }
+    },
   })
 }
 
 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 (err instanceof Error && err.message) {
+    return err.message
+  }
+
+  return fallback
+}
+
 export function setBackendUrl(url) {
-  const cleaned = (url || '').trim().replace(/\/+$/, '')
+  const cleaned = normalizeBackendUrl(url)
   if (cleaned) {
     localStorage.setItem(STORAGE_KEY, cleaned)
   } else {
@@ -26,24 +192,209 @@ export function setBackendUrl(url) {
   api = createApiInstance()
 }
 
+export function setBackendInvite(invite) {
+  const cleaned = (invite || '').trim()
+  if (cleaned) {
+    localStorage.setItem(INVITE_STORAGE_KEY, cleaned)
+  } else {
+    localStorage.removeItem(INVITE_STORAGE_KEY)
+  }
+  api = createApiInstance()
+}
+
+export function configureBackend({ url, invite }) {
+  setBackendUrl(url)
+  setBackendInvite(invite)
+}
+
+export function clearBackendConnection() {
+  setBackendUrl('')
+  setBackendInvite('')
+}
+
 export function getBackendUrlExport() {
   return getBackendUrl()
 }
 
+export function getRemoteBackendUrlExport() {
+  return getRemoteBackendUrl()
+}
+
+export function getBackendInviteExport() {
+  return getBackendInvite()
+}
+
+export function getApiUrl(path) {
+  const url = getBackendUrl()
+  return `${url}${normalizePath(path)}`
+}
+
+export async function getApiRequestHeaders(method = 'GET', path = '/') {
+  /** @type {Record<string, string>} */
+  const headers = {}
+  const invite = getBackendInvite()
+  if (invite && shouldAttachBackendInvite()) {
+    headers['x-mostbox-invite'] = invite
+  }
+  try {
+    Object.assign(
+      headers,
+      await buildAuthHeaders(
+        getStoredIdentity(),
+        method,
+        normalizeAuthPath(path)
+      )
+    )
+  } catch {
+    // Callers that require auth will receive the server's 401 response.
+  }
+  return headers
+}
+
+export function getWebSocketUrl(path = '/ws') {
+  if (typeof window === 'undefined') return normalizePath(path)
+
+  const base = getBackendUrl() || window.location.origin
+  return buildWebSocketUrl(base, path)
+}
+
+export async function getAuthenticatedWebSocketUrl(path = '/ws') {
+  if (typeof window === 'undefined') return normalizePath(path)
+
+  const base = getBackendUrl() || window.location.origin
+  const url = new URL(buildWebSocketUrl(base, path))
+
+  const invite = getBackendInvite()
+  if (invite && shouldAttachBackendInvite(url.toString())) {
+    url.searchParams.set('invite', invite)
+  }
+
+  const identity = getStoredIdentity()
+  if (identity?.danger) {
+    try {
+      const auth = await buildAuthHeaders(
+        identity,
+        'GET',
+        normalizeAuthPath(path)
+      )
+      const [address, timestamp, signature] = String(
+        auth.Authorization || ''
+      ).split(',')
+      if (address && signature) {
+        url.searchParams.set('address', address)
+        url.searchParams.set('timestamp', timestamp)
+        url.searchParams.set('signature', signature)
+      }
+    } catch {
+      // Leave WebSocket unauthenticated when local identity data is invalid.
+    }
+  }
+
+  return url.toString()
+}
+
 export async function checkBackendConnection() {
   const url = getBackendUrl()
+  const invite = shouldAttachBackendInvite(url) ? getBackendInvite() : ''
+  return checkBackendConnectionTarget({ url, invite })
+}
+
+async function probeHttp(cleanedUrl, invite, identity) {
   try {
-    const res = await fetch(`${url}/api/node-id`, {
+    const headers = {}
+    if (invite) headers['x-mostbox-invite'] = invite
+    try {
+      Object.assign(
+        headers,
+        await buildAuthHeaders(identity, 'GET', '/api/remote/capabilities')
+      )
+    } catch {
+      // Backend detection should still work when old identity data is invalid.
+    }
+    const res = await fetch(`${cleanedUrl}/api/remote/capabilities`, {
       method: 'GET',
+      headers,
       signal: AbortSignal.timeout(3000),
     })
-    return res.ok
+    if (!res.ok) return { ok: false, reason: 'http' }
+    return { ok: true }
   } catch {
-    return false
+    return { ok: false, reason: 'http' }
+  }
+}
+
+async function probeWebSocket(cleanedUrl, invite, identity) {
+  if (typeof WebSocket === 'undefined') return { ok: true }
+
+  try {
+    const wsUrl = new URL(buildWebSocketUrl(cleanedUrl))
+
+    if (invite) {
+      wsUrl.searchParams.set('invite', invite)
+    }
+
+    if (identity?.danger) {
+      try {
+        const auth = await buildAuthHeaders(
+          identity,
+          'GET',
+          normalizeAuthPath('/ws')
+        )
+        const [address, timestamp, signature] = String(
+          auth.Authorization || ''
+        ).split(',')
+        if (address && signature) {
+          wsUrl.searchParams.set('address', address)
+          wsUrl.searchParams.set('timestamp', timestamp)
+          wsUrl.searchParams.set('signature', signature)
+        }
+      } catch {
+        // Leave WebSocket unauthenticated when local identity data is invalid.
+      }
+    }
+
+    return await new Promise(resolve => {
+      const ws = new WebSocket(wsUrl.toString())
+      const timeout = setTimeout(() => {
+        ws.close()
+        resolve({ ok: false, reason: 'ws' })
+      }, 4000)
+
+      ws.onopen = () => {
+        clearTimeout(timeout)
+        ws.close()
+        resolve({ ok: true })
+      }
+
+      ws.onerror = () => {
+        clearTimeout(timeout)
+        resolve({ ok: false, reason: 'ws' })
+      }
+    })
+  } catch {
+    return { ok: false, reason: 'ws' }
   }
 }
 
+export async function checkBackendConnectionTarget({ url, invite = '' }) {
+  const cleanedUrl = normalizeBackendUrl(url)
+  if (!cleanedUrl) return { ok: false, reason: 'http' }
+
+  const identity = getStoredIdentity()
+
+  const [httpResult, wsResult] = await Promise.all([
+    probeHttp(cleanedUrl, invite, identity),
+    probeWebSocket(cleanedUrl, invite, identity),
+  ])
+
+  if (!httpResult.ok) return httpResult
+  if (!wsResult.ok) return wsResult
+  return { ok: true }
+}
+
 export async function detectSameOriginBackend() {
+  if (isLocalFrontendOrigin()) return false
+
   try {
     const res = await fetch('/api/node-id', {
       method: 'GET',
@@ -57,7 +408,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),
     })