custom server

Author: peezy

app-server/TODO.md

@@ -0,0 +1,14 @@
+- [ ] test merged servers (esbuild and hotreload)
+- [ ] simplify 'blueprint' object in `world-links.json`
+- [ ] add scripting docs
+- [ ] how to handle deletions? 
+- [ ] claude instructions
+    - [ ] maybe commands or subagent definitions
+- [ ] typescript
+- [ ] `__HYPERFY_CONFIG__` and `app.configure` are redundant. think about how to merge without changing syntax too much.
+- [ ] save auth token of connection
+- [ ] make browserless connection via node client (update apps on many worlds)
+- [ ] maybe remove `eval` from `build.mjs`
+- [ ] better conflict resolution (linking app with already existing name)
+- [ ] auto link on deploy
+- [ ] merge cli and server into single terminal interface program

app-server/apps/cube/index.js

@@ -0,0 +1,32 @@
+import { send } from '~/utils.js'
+
+const __HYPERFY_CONFIG__ = {
+  model: "cube",
+  props: {
+    message: "hello worlder!"
+  }
+};
+
+app.configure([
+  {
+    key: 'message',
+    type: 'text',
+    label: 'Message',
+    hint: 'A message to be sent to the client.'
+  },
+  {
+    key: 'send',
+    type: 'button',
+    label: 'Send',
+    hint: 'Send the message to the boys.',
+    onClick: () => {
+      send(app.props.message)
+    }
+  }
+])
+
+if(world.isServer) {
+  app.on('sendMessage', (message) => {
+    console.log('Message received:', message)
+  })
+}

app-server/assets/cube.glb

@@ -0,0 +1,206 @@
+import * as esbuild from 'esbuild'
+import fs from 'fs/promises'
+import path from 'path'
+import crypto from 'crypto'
+
+const dev = process.argv.includes('--dev')
+
+// Hash function copied from utils-server.js
+async function hashFile(file) {
+  const hash = crypto.createHash('sha256')
+  hash.update(file)
+  return hash.digest('hex')
+}
+
+// Get all available apps from the apps directory
+async function getAvailableApps() {
+  const appsDir = 'apps'
+  try {
+    const entries = await fs.readdir(appsDir, { withFileTypes: true })
+    const appFolders = entries
+      .filter(entry => entry.isDirectory())
+      .map(entry => entry.name)
+    
+    // Filter for apps that have an index.js file
+    const validApps = []
+    for (const appName of appFolders) {
+      const indexPath = path.join(appsDir, appName, 'index.js')
+      try {
+        await fs.access(indexPath)
+        validApps.push(appName)
+      } catch {
+        // index.js doesn't exist, skip this app
+      }
+    }
+    
+    return validApps
+  } catch (error) {
+    console.error('Error reading apps directory:', error)
+    return []
+  }
+}
+
+// Extract config from source file
+function extractConfig(source) {
+  // Look for const __HYPERFY_CONFIG__ = { ... }
+  const configRegex = /const\s+__HYPERFY_CONFIG__\s*=\s*({[\s\S]*?});/
+  const match = source.match(configRegex)
+  
+  if (!match) {
+    throw new Error('No __HYPERFY_CONFIG__ found in source file')
+  }
+  
+  try {
+    // Use eval to parse the object literal (safe since we control the source)
+    const configObj = eval(`(${match[1]})`)
+    return configObj
+  } catch (error) {
+    throw new Error(`Failed to parse __HYPERFY_CONFIG__: ${error.message}`)
+  }
+}
+
+// Generate config.json in build directory for a specific app
+async function generateConfig(appName) {
+  // Read the source index.js file to extract config
+  const sourceIndexPath = path.join('apps', appName, 'index.js')
+  const sourceContent = await fs.readFile(sourceIndexPath, 'utf-8')
+  const sourceConfig = extractConfig(sourceContent)
+  
+  // Hash the built JS file
+  const builtJsPath = path.join('build', appName, 'index.js')
+  const jsContent = await fs.readFile(builtJsPath)
+  const jsHash = await hashFile(jsContent)
+  
+  // Hash the model asset file
+  const modelAssetPath = path.join('assets', `${sourceConfig.model}.glb`)
+  let modelHash
+  try {
+    const modelContent = await fs.readFile(modelAssetPath)
+    modelHash = await hashFile(modelContent)
+  } catch (error) {
+    throw new Error(`Model asset not found: ${modelAssetPath}. Expected file: ${sourceConfig.model}.glb`)
+  }
+  
+  // Generate the new config
+  const buildConfig = {
+    name: appName,
+    script: `asset://${jsHash}.js`,
+    model: `asset://${modelHash}.glb`,
+    props: sourceConfig.props
+  }
+  
+  // Ensure build directory exists for this app
+  const buildDir = path.join('build', appName)
+  await fs.mkdir(buildDir, { recursive: true })
+  
+  // Write the config to build directory
+  const buildConfigPath = path.join('build', appName, 'config.json')
+  await fs.writeFile(buildConfigPath, JSON.stringify(buildConfig, null, 2))
+  
+  console.log(`Generated config.json for ${appName}`)
+}
+
+// Generate configs for all built apps
+async function generateAllConfigs(appNames) {
+  for (const appName of appNames) {
+    try {
+      await generateConfig(appName)
+    } catch (error) {
+      console.error(`Failed to generate config for ${appName}:`, error.message)
+    }
+  }
+}
+
+// Get all available apps
+const availableApps = await getAvailableApps()
+
+if (availableApps.length === 0) {
+  console.log('No apps found to build')
+  process.exit(0)
+}
+
+console.log(`Found ${availableApps.length} app(s) to build: ${availableApps.join(', ')}`)
+
+// Build each app separately
+const buildPromises = availableApps.map(async (appName) => {
+  console.log(`Building ${appName}...`)
+  
+  const ctx = await esbuild.context({
+    // Build settings applied to all apps
+    format: 'esm',
+    bundle: true,
+    minify: false, // true for production builds
+    sourcemap: true, // for debugging
+    external: ['hyperfy'], // runtime-provided globals
+
+    // Shared code resolution paths
+    alias: {
+      '~': './',
+    },
+   
+    splitting: false, 
+    treeShaking: true,
+    entryPoints: [path.join('apps', appName, 'index.js')],
+    outfile: path.join('build', appName, 'index.js'),
+    plugins: [
+      {
+        name: 'config-stripper',
+        setup(build) {
+          // Remove __HYPERFY_CONFIG__ from the source during build
+          build.onLoad({ filter: /\/apps\/.*\/index\.js$/ }, async (args) => {
+            const source = await fs.readFile(args.path, 'utf-8')
+            
+            // Remove the __HYPERFY_CONFIG__ const declaration
+            const strippedSource = source.replace(
+              /const\s+__HYPERFY_CONFIG__\s*=\s*{[\s\S]*?};\s*/,
+              ''
+            )
+            
+            return {
+              contents: strippedSource,
+              loader: 'js'
+            }
+          })
+        }
+      },
+      {
+        name: 'config-generator',
+        setup(build) {
+          build.onEnd(async () => {
+            try {
+              await generateConfig(appName)
+            } catch (error) {
+              console.error(`Failed to generate config for ${appName}:`, error.message)
+            }
+          })
+        }
+      }
+    ]
+  })
+
+  if (dev) {
+    await ctx.watch()
+    console.log(`Watching ${appName} for changes...`)
+    return ctx // Return context for cleanup later
+  } else {
+    await ctx.rebuild()
+    await ctx.dispose()
+    console.log(`Built ${appName} successfully`)
+    return null
+  }
+})
+
+if (dev) {
+  const contexts = await Promise.all(buildPromises)
+  console.log('Watching all apps for changes...')
+  
+  // Handle cleanup on exit
+  process.on('SIGINT', async () => {
+    console.log('\nCleaning up...')
+    await Promise.all(contexts.filter(ctx => ctx).map(ctx => ctx.dispose()))
+    process.exit(0)
+  })
+} else {
+  await Promise.all(buildPromises)
+  console.log('All apps built successfully')
+}

app-server/build.mjs

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+
+import fs from 'fs/promises'
+import path from 'path'
+import crypto from 'crypto'
+
+// Hash function (same as in build.mjs)
+async function hashFile(file) {
+  const hash = crypto.createHash('sha256')
+  hash.update(file)
+  return hash.digest('hex')
+}
+
+// Get all files in assets directory
+async function getAssetFiles(assetsDir = 'assets') {
+  const files = []
+  
+  try {
+    const entries = await fs.readdir(assetsDir, { withFileTypes: true })
+    
+    for (const entry of entries) {
+      if (entry.isFile() && entry.name !== 'names.json') {
+        const filePath = path.join(assetsDir, entry.name)
+        files.push({
+          name: entry.name,
+          path: filePath
+        })
+      }
+    }
+  } catch (error) {
+    console.error(`Error reading assets directory: ${error.message}`)
+    return []
+  }
+  
+  return files
+}
+
+// Check for duplicate files by comparing hashes
+async function checkDuplicates() {
+  console.log('🔍 Checking for duplicate assets...\n')
+  
+  const assetFiles = await getAssetFiles()
+  
+  if (assetFiles.length === 0) {
+    console.log('📁 No asset files found')
+    return
+  }
+  
+  console.log(`📂 Found ${assetFiles.length} asset file(s)`)
+  
+  const hashMap = new Map() // hash -> array of files with that hash
+  const fileHashes = new Map() // filename -> hash
+  
+  // Calculate hashes for all files
+  for (const file of assetFiles) {
+    try {
+      const content = await fs.readFile(file.path)
+      const hash = await hashFile(content)
+      
+      fileHashes.set(file.name, hash)
+      
+      if (!hashMap.has(hash)) {
+        hashMap.set(hash, [])
+      }
+      hashMap.get(hash).push(file)
+      
+      console.log(`📄 ${file.name} -> ${hash}`)
+    } catch (error) {
+      console.error(`❌ Error processing ${file.name}: ${error.message}`)
+    }
+  }
+  
+  console.log()
+  
+  // Find duplicates
+  const duplicates = []
+  for (const [hash, files] of hashMap.entries()) {
+    if (files.length > 1) {
+      duplicates.push({ hash, files })
+    }
+  }
+  
+  if (duplicates.length === 0) {
+    console.log('✅ No duplicate assets found! All files are unique.')
+  } else {
+    console.log(`⚠️  Found ${duplicates.length} group(s) of duplicate assets:\n`)
+    
+    duplicates.forEach((group, index) => {
+      console.log(`🔗 Duplicate Group ${index + 1} (hash: ${group.hash}):`)
+      group.files.forEach(file => {
+        console.log(`   - ${file.name}`)
+      })
+      console.log()
+    })
+    
+    console.log('💡 Consider removing duplicate files to save space and avoid confusion.')
+  }
+  
+  // Summary
+  console.log('\n📊 Summary:')
+  console.log(`   Total files: ${assetFiles.length}`)
+  console.log(`   Unique files: ${hashMap.size}`)
+  console.log(`   Duplicate groups: ${duplicates.length}`)
+  
+  if (duplicates.length > 0) {
+    const duplicateFileCount = duplicates.reduce((sum, group) => sum + group.files.length - 1, 0)
+    console.log(`   Duplicate files: ${duplicateFileCount}`)
+  }
+}
+
+// Run the check
+checkDuplicates().catch(error => {
+  console.error('❌ Error checking duplicates:', error.message)
+  process.exit(1)
+})